Go로 REST API 구축: 완전 가이드

Go의 강력한 생태계를 활용하여 프로덕션 준비가 완료된 REST API를 구축하세요.

Page content

고성능 REST API 구축은 Google, Uber, Dropbox 및 수많은 스타트업에서 시스템을 구동하는 표준 접근법이 되었습니다.

Go의 간단함, 강력한 동시성 지원, 빠른 컴파일은 마이크로서비스 및 백엔드 개발에 이상적입니다.

go api 이 훌륭한 이미지는 FLUX.1-Kontext-dev: Image Augmentation AI Model에 의해 생성되었습니다. FLUX.1-Kontext-dev는 텍스트 프롬프트를 사용하여 이미지에서 이미지 생성을 가능하게 합니다.

API 개발을 위한 Go의 장점

Go는 API 개발에 다음과 같은 매력적인 이점을 제공합니다:

성능 및 효율성: Go는 네이티브 머신 코드로 컴파일되어 C에 가까운 성능을 제공하지만 복잡성은 없습니다. 효율적인 메모리 관리 및 작은 바이너리 크기로 인해 컨테이너 배포에 완벽합니다.

내장 동시성: Goroutines과 channels은 수천 개의 동시 요청을 처리하는 것을 간단하게 만듭니다. 복잡한 스레드 코드 없이 여러 API 요청을 동시에 처리할 수 있습니다.

강력한 표준 라이브러리: net/http 패키지는 즉시 사용 가능한 HTTP 서버를 제공합니다. 외부 의존성을 사용하지 않고도 완전한 API를 구축할 수 있습니다.

빠른 컴파일: Go의 컴파일 속도는 개발 중 빠른 반복을 가능하게 합니다. 대규모 프로젝트도 몇 초 만에 컴파일됩니다.

간단한 정적 타이핑: Go의 타입 시스템은 컴파일 시 오류를 잡으면서도 코드 명확성을 유지합니다. 언어는 학습하기 쉬운 작은 기능 집합을 제공합니다.

Go에서 API를 구축하는 방법

표준 라이브러리 사용

Go의 표준 라이브러리는 기본적인 API 개발에 필요한 모든 것을 제공합니다. 다음은 최소한의 예시입니다:

package main

import (
    "encoding/json"
    "log"
    "net/http"
)

type Response struct {
    Message string `json:"message"`
    Status  int    `json:"status"`
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(Response{
        Message: "API is healthy",
        Status:  200,
    })
}

func main() {
    http.HandleFunc("/health", healthHandler)
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

이 접근법은 완전한 제어와 의존성 없이 제공됩니다. 간단한 API 또는 기본 수준에서 HTTP 처리를 이해하고 싶을 때 이상적입니다.

인기 있는 Go 웹 프레임워크

표준 라이브러리는 강력하지만, 프레임워크는 개발 속도를 높일 수 있습니다:

Gin: 가장 인기 있는 Go 웹 프레임워크로, 성능과 사용 편의성을 제공합니다. 편리한 라우팅, 미들웨어 지원 및 요청 검증을 제공합니다.

package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

func main() {
    r := gin.Default()
    
    r.GET("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        c.JSON(http.StatusOK, gin.H{
            "user_id": id,
            "name": "John Doe",
        })
    })
    
    r.Run(":8080")
}

Chi: 표준 라이브러리의 확장으로 느껴지는 가볍고 직관적인 라우터입니다. 중첩된 라우팅으로 RESTful 서비스를 구축하는 데 특히 적합합니다.

Echo: 광범위한 미들웨어와 우수한 문서를 제공하는 고성능 프레임워크입니다. 속도를 최적화하면서도 개발자 친화적입니다.

Fiber: Express.js에 영감을 받아 Fasthttp 위에 구축되었습니다. 가장 빠른 옵션이지만 표준 라이브러리와 다른 HTTP 구현을 사용합니다.

아키텍처 패턴

Go에서 데이터베이스 작업을 수행할 때 ORM 전략을 고려해야 합니다. 다양한 프로젝트에서 GORM, Ent, Bun, sqlc와 같은 접근 방식을 비교한 적이 있습니다. 각각은 개발자 생산성과 성능 사이에서 다른 트레이드오프를 제공합니다.

계층형 아키텍처

관심사의 명확한 분리를 위해 API를 구조화하십시오:

// 핸들러 레이어 - HTTP 관련 문제
type UserHandler struct {
    service *UserService
}

func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
    id := chi.URLParam(r, "id")
    user, err := h.service.GetByID(r.Context(), id)
    if err != nil {
        respondError(w, err)
        return
    }
    respondJSON(w, user)
}

// 서비스 레이어 - 비즈니스 로직
type UserService struct {
    repo *UserRepository
}

func (s *UserService) GetByID(ctx context.Context, id string) (*User, error) {
    // 검증, 변환, 비즈니스 규칙 적용
    return s.repo.FindByID(ctx, id)
}

// 저장소 레이어 - 데이터 접근
type UserRepository struct {
    db *sql.DB
}

func (r *UserRepository) FindByID(ctx context.Context, id string) (*User, error) {
    // 데이터베이스 쿼리 구현
}

이 분리 방식은 테스트를 더 쉽게 만들고 프로젝트가 커질수록 코드를 유지보수하기 쉬워집니다.

도메인 주도 설계

복잡한 애플리케이션에서는 도메인 기반으로 코드를 구성하는 것이 기술 계층보다 더 좋습니다. 각 도메인 패키지는 자체 모델, 서비스 및 저장소를 포함합니다.

다중 테넌트 애플리케이션을 구축 중이라면, 다중 테넌트 데이터베이스 패턴을 이해하는 것이 API 아키텍처에 필수적입니다.

요청 처리 및 검증

입력 검증

처리하기 전에 들어오는 데이터를 항상 검증하십시오:

type CreateUserRequest struct {
    Email    string `json:"email" validate:"required,email"`
    Username string `json:"username" validate:"required,min=3,max=50"`
    Age      int    `json:"age" validate:"gte=0,lte=150"`
}

func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) {
    var req CreateUserRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        respondError(w, NewBadRequestError("Invalid JSON"))
        return
    }
    
    validate := validator.New()
    if err := validate.Struct(req); err != nil {
        respondError(w, NewValidationError(err))
        return
    }
    
    // 유효한 요청 처리
}

go-playground/validator 패키지는 광범위한 검증 규칙과 커스텀 검증기를 제공합니다.

요청 컨텍스트

요청 범위 값 및 취소를 위해 컨텍스트를 사용하십시오:

func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        userID, err := validateToken(token)
        if err != nil {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        
        ctx := context.WithValue(r.Context(), "userID", userID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

인증 및 보안

JWT 기반 인증

JSON 웹 토큰은 상태 없는 인증을 제공합니다:

import "github.com/golang-jwt/jwt/v5"

func generateToken(userID string) (string, error) {
    claims := jwt.MapClaims{
        "user_id": userID,
        "exp":     time.Now().Add(time.Hour * 24).Unix(),
    }
    
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString([]byte(os.Getenv("JWT_SECRET")))
}

func validateToken(tokenString string) (string, error) {
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        return []byte(os.Getenv("JWT_SECRET")), nil
    })
    
    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        return claims["user_id"].(string), nil
    }
    return "", err
}

미들웨어 패턴

교차 관심사를 미들웨어로 구현하십시오:

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        log.Printf("Started %s %s", r.Method, r.URL.Path)
        
        next.ServeHTTP(w, r)
        
        log.Printf("Completed in %v", time.Since(start))
    })
}

func rateLimitMiddleware(next http.Handler) http.Handler {
    limiter := rate.NewLimiter(10, 20) // 10 requests/sec, burst of 20
    
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if !limiter.Allow() {
            http.Error(w, "Rate limit exceeded", http.StatusTooManyRequests)
            return
        }
        next.ServeHTTP(w, r)
    })
}

오류 처리

일관된 오류 응답을 구현하십시오:

type APIError struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
    Details string `json:"details,omitempty"`
}

func (e *APIError) Error() string {
    return e.Message
}

func NewBadRequestError(message string) *APIError {
    return &APIError{
        Code:    http.StatusBadRequest,
        Message: message,
    }
}

func NewNotFoundError(resource string) *APIError {
    return &APIError{
        Code:    http.StatusNotFound,
        Message: fmt.Sprintf("%s not found", resource),
    }
}

func respondError(w http.ResponseWriter, err error) {
    apiErr, ok := err.(*APIError)
    if !ok {
        apiErr = &APIError{
            Code:    http.StatusInternalServerError,
            Message: "Internal server error",
        }
        // 디버깅을 위해 실제 오류 로깅
        log.Printf("Unexpected error: %v", err)
    }
    
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(apiErr.Code)
    json.NewEncoder(w).Encode(apiErr)
}

데이터베이스 통합

연결 관리

효율적인 데이터베이스 접근을 위해 연결 풀을 사용하십시오:

func initDB() (*sql.DB, error) {
    db, err := sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if err != nil {
        return nil, err
    }
    
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(5 * time.Minute)
    
    return db, db.Ping()
}

쿼리 패턴

안전한 데이터베이스 작업을 위해 준비된 명령문과 컨텍스트를 사용하십시오:

func (r *UserRepository) FindByEmail(ctx context.Context, email string) (*User, error) {
    query := `SELECT id, email, username, created_at FROM users WHERE email = $1`
    
    var user User
    err := r.db.QueryRowContext(ctx, query, email).Scan(
        &user.ID,
        &user.Email,
        &user.Username,
        &user.CreatedAt,
    )
    
    if err == sql.ErrNoRows {
        return nil, ErrUserNotFound
    }
    return &user, err
}

테스트 전략

핸들러 테스트

httptest를 사용하여 HTTP 핸들러를 테스트하십시오:

func TestGetUserHandler(t *testing.T) {
    // 설정
    mockService := &MockUserService{
        GetByIDFunc: func(ctx context.Context, id string) (*User, error) {
            return &User{ID: "1", Username: "testuser"}, nil
        },
    }
    handler := &UserHandler{service: mockService}
    
    // 실행
    req := httptest.NewRequest("GET", "/users/1", nil)
    w := httptest.NewRecorder()
    handler.GetUser(w, req)
    
    // 주장
    assert.Equal(t, http.StatusOK, w.Code)
    
    var response User
    json.Unmarshal(w.Body.Bytes(), &response)
    assert.Equal(t, "testuser", response.Username)
}

통합 테스트

테스트 데이터베이스를 사용하여 완전한 워크플로우를 테스트하십시오:

func TestCreateUserEndToEnd(t *testing.T) {
    // 테스트 데이터베이스 설정
    db := setupTestDB(t)
    defer db.Close()
    
    // 테스트 서버 시작
    server := setupTestServer(db)
    defer server.Close()
    
    // 요청
    body := strings.NewReader(`{"email":"test@example.com","username":"testuser"}`)
    resp, err := http.Post(server.URL+"/users", "application/json", body)
    require.NoError(t, err)
    defer resp.Body.Close()
    
    // 응답 검증
    assert.Equal(t, http.StatusCreated, resp.StatusCode)
    
    // 데이터베이스 상태 검증
    var count int
    db.QueryRow("SELECT COUNT(*) FROM users WHERE email = $1", "test@example.com").Scan(&count)
    assert.Equal(t, 1, count)
}

API 문서화

OpenAPI/Swagger

OpenAPI 명세를 사용하여 API를 문서화하십시오:

// @title User API
// @version 1.0
// @description API for managing users
// @host localhost:8080
// @BasePath /api/v1

// @Summary Get user by ID
// @Description Retrieves a user's information by their ID
// @Tags users
// @Accept json
// @Produce json
// @Param id path string true "User ID"
// @Success 200 {object} User
// @Failure 404 {object} APIError
// @Router /users/{id} [get]
func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
    // 구현
}

swaggo/swag를 사용하여 이러한 주석에서 상호작용형 API 문서를 생성하십시오.

성능 최적화

응답 압축

응답에 gzip 압축을 활성화하십시오:

import "github.com/NYTimes/gziphandler"

func main() {
    r := chi.NewRouter()
    r.Use(gziphandler.GzipHandler)
    // 나머지 설정
}

캐싱

자주 액세스되는 데이터에 대한 캐싱을 구현하십시오:

import "github.com/go-redis/redis/v8"

type CachedUserRepository struct {
    repo  *UserRepository
    cache *redis.Client
}

func (r *CachedUserRepository) GetByID(ctx context.Context, id string) (*User, error) {
    // 먼저 캐시를 시도
    cached, err := r.cache.Get(ctx, "user:"+id).Result()
    if err == nil {
        var user User
        json.Unmarshal([]byte(cached), &user)
        return &user, nil
    }
    
    // 캐시 미스 - 데이터베이스에서 가져오기
    user, err := r.repo.FindByID(ctx, id)
    if err != nil {
        return nil, err
    }
    
    // 캐시에 저장
    data, _ := json.Marshal(user)
    r.cache.Set(ctx, "user:"+id, data, 10*time.Minute)
    
    return user, nil
}

연결 풀링

외부 API 호출에 대해 HTTP 연결을 재사용하십시오:

var httpClient = &http.Client{
    Timeout: 10 * time.Second,
    Transport: &http.Transport{
        MaxIdleConns:        100,
        MaxIdleConnsPerHost: 10,
        IdleConnTimeout:     90 * time.Second,
    },
}

배포 고려 사항

Docker 컨테이너화

다단계 빌드를 사용하여 효율적인 Docker 이미지를 생성하십시오:

# 빌드 단계
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o api ./cmd/api

# 프로덕션 단계
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/api .
EXPOSE 8080
CMD ["./api"]

이렇게 하면 일반적으로 20MB 미만의 최소 이미지를 생성합니다.

구성 관리

환경 변수 및 구성 파일을 사용하십시오:

type Config struct {
    Port        string
    DatabaseURL string
    JWTSecret   string
    LogLevel    string
}

func LoadConfig() (*Config, error) {
    return &Config{
        Port:        getEnv("PORT", "8080"),
        DatabaseURL: getEnv("DATABASE_URL", ""),
        JWTSecret:   getEnv("JWT_SECRET", ""),
        LogLevel:    getEnv("LOG_LEVEL", "info"),
    }, nil
}

func getEnv(key, defaultValue string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultValue
}

부드러운 종료

종료 신호를 적절히 처리하십시오:

func main() {
    server := &http.Server{
        Addr:    ":8080",
        Handler: setupRouter(),
    }
    
    // 서버를 별도의 고루틴에서 시작
    go func() {
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server error: %v", err)
        }
    }()
    
    // 인터럽트 신호 대기
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    
    log.Println("Shutting down server...")
    
    // 요청이 완료될 수 있도록 30초 제공
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    if err := server.Shutdown(ctx); err != nil {
        log.Fatalf("Server forced to shutdown: %v", err)
    }
    
    log.Println("Server exited")
}

모니터링 및 관찰 가능성

구조화된 로깅

더 나은 검색 가능성을 위해 구조화된 로깅을 사용하십시오:

import "go.uber.org/zap"

func setupLogger() (*zap.Logger, error) {
    config := zap.NewProductionConfig()
    config.OutputPaths = []string{"stdout"}
    return config.Build()
}

func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
    logger := h.logger.With(
        zap.String("method", r.Method),
        zap.String("path", r.URL.Path),
        zap.String("user_id", r.Context().Value("userID").(string)),
    )
    
    logger.Info("Processing request")
    // 핸들러 로직
}

메트릭 수집

Prometheus 메트릭을 노출하십시오:

import "github.com/prometheus/client_golang/prometheus"

var (
    requestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name: "http_request_duration_seconds",
            Help: "Duration of HTTP requests",
        },
        []string{"method", "path", "status"},
    )
)

func init() {
    prometheus.MustRegister(requestDuration)
}

func metricsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        recorder := &statusRecorder{ResponseWriter: w, status: 200}
        
        next.ServeHTTP(recorder, r)
        
        duration := time.Since(start).Seconds()
        requestDuration.WithLabelValues(
            r.Method,
            r.URL.Path,
            strconv.Itoa(recorder.status),
        ).Observe(duration)
    })
}

고급 패턴

구조화된 출력 작업

LLM과 통합하는 API를 구축할 때, 구조화된 출력으로 응답 제한이 필요할 수 있습니다. 이는 특히 API의 AI 기능에 매우 유용합니다.

API 데이터 소스를 위한 웹 스크래핑

API가 다른 웹사이트의 데이터를 집계해야 한다면, Beautiful Soup의 Go 대안을 이해하는 것이 강력한 웹 스크래핑 기능을 구현하는 데 도움이 됩니다.

문서 생성

많은 API가 문서를 생성해야 합니다. Go에서 PDF 생성을 위해 여러 라이브러리와 접근법을 통합할 수 있습니다.

의미 검색 및 재정렬

문자열 검색 및 검색을 다루는 API에 대해, 임베딩 모델을 사용한 재정렬을 구현하면 검색 결과의 관련성을 크게 향상시킬 수 있습니다.

MCP 서버 구축

Model Context Protocol을 따르는 API를 구현하는 경우, Go에서 MCP 서버 구현에 대한 이 가이드를 참고하십시오. 이는 프로토콜 명세 및 실용적인 구현을 다룹니다.

일반적인 함정 및 해결책

컨텍스트를 올바르게 사용하지 않음

호출 체인 전체에서 항상 컨텍스트를 전달하고 존중해야 합니다. 이는 적절한 취소 및 타임아웃 처리를 가능하게 합니다.

고루틴 누수 무시

모든 고루틴이 종료될 수 있도록 보장하십시오. 죽음의 기한을 가진 컨텍스트를 사용하고 항상 완료 신호를 보내는 방법이 있어야 합니다.

부족한 오류 처리

클라이언트에게 원시 데이터베이스 오류를 반환하지 마십시오. 오류를 컨텍스트로 감싸고 API 응답에 정리된 메시지를 반환하십시오.

입력 검증 누락

입력은 경계에서 항상 검증해야 합니다. 인증된 사용자로부터도 클라이언트 데이터를 신뢰하지 마십시오.

불충분한 테스트

행복한 경로만 테스트하지 마십시오. 오류 사례, 경계 조건, 동시 접근 시나리오를 모두 커버하십시오.

최고의 실천 요약

  1. 간단하게 시작: 표준 라이브러리로 시작하십시오. 복잡성이 요구되면 프레임워크를 추가하십시오.

  2. 레이어를 분리: HTTP 핸들러, 비즈니스 로직, 데이터 접근을 분리하여 유지보수성을 높이십시오.

  3. 모든 것을 검증: 경계에서 입력을 검증하십시오. 강력한 타이핑과 검증 라이브러리를 사용하십시오.

  4. 일관된 오류 처리: 구조화된 오류 응답을 반환하십시오. 내부 오류는 로깅하지만 외부에 노출하지 마십시오.

  5. 미들웨어 사용: 인증, 로깅, 메트릭과 같은 교차 관심사를 미들웨어로 구현하십시오.

  6. 자체적으로 철저히 테스트: 로직을 위한 단위 테스트, 데이터 접근을 위한 통합 테스트, 워크플로우를 위한 끝까지 테스트를 작성하십시오.

  7. API 문서화: 상호작용형 문서를 위해 OpenAPI/Swagger를 사용하십시오.

  8. 생산 모니터링: 구조화된 로깅, 메트릭 수집, 건강 상태 확인을 구현하십시오.

  9. 주의 깊게 최적화: 프로파일링 전에 최적화하지 마십시오. 캐싱, 연결 풀, 압축이 유익한 경우 사용하십시오.

  10. 부드러운 종료를 위해 설계: 종료 신호를 처리하고 연결을 적절히 드레인하십시오.

시작 체크리스트

Go 프로젝트 작업 시 참조용으로 포괄적인 Go 체크리스트를 소지하는 것이 개발 속도를 높이고 구문 및 일반 패턴에 대한 빠른 참조가 될 수 있습니다.

첫 번째 Go API를 구축하려고 준비되었나요? 다음 단계로 시작하십시오:

  1. ✅ Go 환경 및 프로젝트 구조 설정
  2. ✅ 표준 라이브러리 또는 프레임워크 선택
  3. ✅ 기본 CRUD 엔드포인트 구현
  4. ✅ 요청 검증 및 오류 처리 추가
  5. ✅ 인증 미들웨어 구현
  6. ✅ 데이터베이스 통합 및 연결 풀 사용
  7. ✅ 단위 및 통합 테스트 작성
  8. ✅ API 문서화 추가
  9. ✅ 로깅 및 메트릭 구현
  10. ✅ Docker로 컨테이너화
  11. ✅ CI/CD 파이프라인 설정
  12. ✅ 모니터링과 함께 프로덕션 배포

결론

Go는 성능, 간결성, 강력한 도구 체계를 결합하여 REST API를 구축하는 데 탁월한 기반을 제공합니다. 마이크로서비스, 내부 도구, 공개 API를 구축하든 간에 Go의 생태계는 모든 요구사항에 성숙한 솔루션을 제공합니다.

성공의 열쇠는 견고한 아키텍처 패턴으로 시작하는 것, 처음부터 적절한 오류 처리와 검증을 구현하는 것, 그리고 포괄적인 테스트 커버리지를 구축하는 것입니다. API가 성장하면서 Go의 성능 특성과 강력한 동시성 지원이 큰 도움이 될 것입니다.

API 개발은 반복적인 과정임을 기억하세요. 최소한의 실행 가능한 구현으로 시작해 피드백을 수집하고, 실제 사용 패턴에 따라 접근 방식을 개선하세요. Go의 빠른 컴파일과 직관적인 리팩토링은 이 반복 주기를 매끄럽고 생산적으로 만들어 줍니다.

유용한 링크

외부 자료

공식 문서

인기 있는 프레임워크 및 라이브러리

테스트 및 개발 도구

  • Testify - 일반적인 단언 및 모킹을 위한 도구 키트
  • httptest 패키지 - HTTP 테스트를 위한 표준 라이브러리 유틸리티
  • Swaggo - RESTful API 문서를 자동으로 생성
  • Air - 개발 중 Go 앱의 라이브 리로드

최선의 실천 및 가이드

보안 및 인증

성능 및 모니터링