ドキュメント価格ブログ
お問い合わせ
ログイン無料で新規登録
Back to Tech Articles

GinおよびChiルーター向けのモジュール式で再利用可能なミドルウェアの構築

10月 09, 2025
# Misc

Grace Collins

Solutions Engineer · Leapcell

この記事はEnglish、한국어、Deutschでも利用できます
Cover of "GinおよびChiルーター向けのモジュール式で再利用可能なミドルウェアの構築"

はじめに

Goで堅牢でスケーラブルなWebアプリケーションを構築する世界では、ミドルウェアは、横断的な懸念事項を処理する上で重要な役割を果たします。ユーザー認証、リクエストのロギング、入力検証、コンテンツタイプネゴシエーションなどのシナリオを想像してください。これらの機能をすべてのハンドラー関数に直接実装すると、コードの重複、ロジックの絡み合い、メンテナンスの悪夢につながります。これはまさに、ミドルウェアの力が輝く場所です。これらの共通機能を個別の、交換可能なコンポーネントに抽象化することで、よりクリーンで、よりモジュール化され、保守性の高いコードベースを実現できます。この記事では、Goで最も人気のある2つのWebフレームワーク、GinとChiで、効果的で構成可能で再利用可能なミドルウェアを作成する方法に焦点を当て、開発者がエレガントで効率的なAPIを構築できるようにします。

ミドルウェアの理解：Webアプリケーションのビルディングブロック

GinとChiの詳細に入る前に、ミドルウェアとは何か、そしてそれを取り巻くコアコンセプトを基本的なレベルで理解しましょう。

ミドルウェアとは？

本質的に、ミドルウェアは、メインのハンドラー関数が実行される前または後にHTTPリクエストとレスポンスを処理する関数または関数のセットです。これらは、HTTPリクエストが通過する「パイプライン」を形成し、各ミドルウェアが特定のタスクを実行し、リクエストまたはレスポンスを変更し、その後パイプラインの次の要素に制御を渡して、最終的に最終ハンドラーに到達できるようにします。

コアコンセプト

  • リクエスト/レスポンスのインターセプト: ミドルウェアはHTTPリクエストの流れをインターセプトし、プリプロセス（例：認証）またはポストプロセス（例：レスポンスステータスのロギング）を可能にします。
  • チェイニング/パイプライン: 複数のミドルウェア関数をチェーンしてシーケンスを形成できます。各ミドルウェアは、リクエストをチェーン内の次に渡すか、リクエストを早期に終了するか（例：認証失敗の場合）を決定できます。
  • コンテキスト: ミドルウェアはHTTPコンテキストを活用して、ミドルウェアチェーン全体および最終ハンドラーと共有できるデータを保存および取得することがよくあります。これにより、グローバル変数が回避され、スレッドセーフなデータ共有が促進されます。
  • 再利用性: 適切に設計されたミドルウェアは、変更なしで異なるルートやさまざまなアプリケーションに適用できるほど汎用的であるべきです。
  • 構成可能性: 複数の小さな、単一目的のミドルウェアをより複雑な機能に組み合わせる能力。

GinとChiのミドルウェアシグネチャ

GinとChiは、それぞれ独自のAPIを持っていますが、ミドルウェアを定義するための非常に似たパターンを提供しています。

Ginミドルウェアシグネチャ:

Ginでは、ミドルウェア関数は通常 func(*gin.Context) というシグネチャを持ちます。 gin.Context オブジェクトには、 http.ResponseWriter と *http.Request に加えて、 Next() 、 Abort() 、 Set() のようなリクエストライフサイクルを管理するためのメソッドが含まれています。

// Ginミドルウェアの例：ロガー
func LoggerMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        c.Next() // 次のミドルウェア/ハンドラーを処理
        duration := time.Since(start)
        log.Printf("Request - Method: %s, Path: %s, Status: %d, Duration: %v",
            c.Request.Method, c.Request.URL.Path, c.Writer.Status(), duration)
    }
}

Chiミドルウェアシグネチャ:

Chiのミドルウェアは、標準の net/http インターフェースにさらに忠実に準拠しています。Chiのミドルウェア関数は通常 func(http.Handler) http.Handler というシグネチャを持ちます。この「デコレーター」パターンは非常に強力で、ミドルウェアが http.Handler をラップして新しいものを返すことを可能にします。

// Chiミドルウェアの例：RequestID
func RequestIDMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        reqID := r.Header.Get("X-Request-ID")
        if reqID == "" {
            reqID = uuid.New().String()
        }
        ctx := context.WithValue(r.Context(), RequestIDKey, reqID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// コンテキスト用のキーの定義
type ContextKey string
const RequestIDKey ContextKey = "requestID"

違いに注意してください：Ginの Next() は明示的に次のハンドラーに進みますが、Chiの next.ServeHTTP() はラップされたハンドラーを呼び出します。どちらもリクエスト処理を続行するという同じ目標を達成します。

再利用可能なミドルウェアの作成

再利用性の鍵は、ミドルウェアを可能な限り汎用的で設定可能にすることです。

パラメータ化されたミドルウェア

値をハードコーディングする代わりに、初期化時にミドルウェアを設定できるようにします。

// Gin：レート制限ミドルウェア
func RateLimitMiddleware(maxRequests int, window time.Duration) gin.HandlerFunc {
    // 実際のシナリオでは、これはトークンバケットやリーキバケット、そしておそらく分散ストアのような、より洗練されたレート制限アルゴリズムを使用するでしょう。
    // 簡単のため、IPごとの基本的なインメモリカウンターを使用します。
    ipCounters := make(map[string]int)
    lastResets := make(map[string]time.Time)
    mu := sync.Mutex{}

    return func(c *gin.Context) {
        ip := c.ClientIP()

        mu.Lock()
        defer mu.Unlock()

        if _, ok := lastResets[ip]; !ok || time.Since(lastResets[ip]) > window {
            ipCounters[ip] = 0
            lastResets[ip] = time.Now()
        }

        if ipCounters[ip] >= maxRequests {
            c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{"error": "Too many requests"})
            return
        }

        ipCounters[ip]++
        c.Next()
    }
}

// Chi：認証ミドルウェア
func AuthMiddleware(secretKey string) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            token := r.Header.Get("Authorization")
            if token == "" || !isValidToken(token, secretKey) { // isValidToken は実際の検証関数になります
                http.Error(w, "Unauthorized", http.StatusUnauthorized)
                return
            }
            // トークンが有効な場合、コンテキストにユーザー情報を保存することがあります
            ctx := context.WithValue(r.Context(), UserIDKey, "some_user_id") // UserIDKey が定義されていると仮定
            next.ServeHTTP(w, r.WithContext(ctx))
        })
    }
}

// デモンストレーション用のダミー isValidToken
func isValidToken(token, secretKey string) bool {
    // 実際のアプリではJWT、APIキーなどを検証します
    return token == "Bearer mysecrettoken" && secretKey == "supersecret"
}

オプションパターン付きミドルウェア

複数のオプションパラメータを受け入れるミドルウェアの場合、「オプションパターン」（関数型オプション）は、設定を提供するクリーンな方法です。

// Gin：オプション付きログレベルミドルウェア
type LogLevel int

const (
    LogInfo LogLevel = iota
    LogError
)

type LoggerOptions struct {
    LogLevel LogLevel
    IncludeHeaders bool
}

type LoggerOption func(*LoggerOptions)

func WithLogLevel(level LogLevel) LoggerOption {
    return func(o *LoggerOptions) {
        o.LogLevel = level
    }
}

func WithHeaders() LoggerOption {
    return func(o *LoggerOptions) {
        o.IncludeHeaders = true
    }
}

func ConfigurableLoggerMiddleware(opts ...LoggerOption) gin.HandlerFunc {
    options := LoggerOptions{
        LogLevel: LogInfo,
        IncludeHeaders: false,
    }
    for _, opt := range opts {
        opt(&options)
    }

    return func(c *gin.Context) {
        start := time.Now()
        c.Next()
        duration := time.Since(start)

        if options.LogLevel == LogInfo {
            log.Printf("Request Info - Method: %s, Path: %s, Status: %d, Duration: %v",
                c.Request.Method, c.Request.URL.Path, c.Writer.Status(), duration)
            if options.IncludeHeaders {
                log.Println("Headers:", c.Request.Header)
            }
        } else if options.LogLevel == LogError && c.Writer.Status() >= 400 {
            log.Printf("Request Error - Method: %s, Path: %s, Status: %d, Message: %s",
                c.Request.Method, c.Request.URL.Path, c.Writer.Status(), c.Errors.ByType(gin.ErrorTypePrivate).String())
        }
    }
}

// 使用法：
// r.Use(ConfigurableLoggerMiddleware(WithLogLevel(LogError)))
// r.Use(ConfigurableLoggerMiddleware(WithLogLevel(LogInfo), WithHeaders()))

構成可能なミドルウェアの構築

構成可能性は、ミドルウェア関数が構造化される方法で自然に得られます。各ミドルウェアを単一の責任に焦点を当てることで、それらを簡単に組み合わせて、より複雑な処理パイプラインを作成できます。

// Ginの例：複数のミドルウェアの組み合わせ
func setupGinRouter() *gin.Engine {
    r := gin.New()

    // すべてのルートに適用されるグローバルミドルウェア
    r.Use(gin.Logger()) // Ginの組み込みロガー
    r.Use(gin.Recovery()) // Ginの組み込みリカバリー
    r.Use(RateLimitMiddleware(10, time.Minute)) // カスタムレート制限

    // ルートのグループに特定のミドルウェアを適用
    adminGroup := r.Group("/admin")
    adminGroup.Use(AuthMiddleware("supersecret")) // カスタム認証
    {
        adminGroup.GET("/dashboard", func(c *gin.Context) {
            c.JSON(http.StatusOK, gin.H{"message": "Welcome Admin!"})
        })
    }

    r.GET("/public", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"message": "Public access"})
    })

    return r
}

// Chiの例：複数のミドルウェアの組み合わせ
func setupChiRouter() http.Handler {
    r := chi.NewRouter()

    // すべてのルートに適用されるグローバルミドルウェア
    r.Use(middleware.Logger) // Chiの組み込みロガー
    r.Use(middleware.Recoverer) // Chiの組み込みリカバリー
    r.Use(RequestIDMiddleware) // カスタムリクエストID

    // ルートのグループに特定のミドルウェアを適用
    r.Group(func(adminRouter chi.Router) {
        adminRouter.Use(AuthMiddleware("supersecret")) // カスタム認証
        adminRouter.Get("/admin/dashboard", func(w http.ResponseWriter, r *http.Request) {
            w.Write([]byte("Welcome Admin!"))
        })
    })

    r.Get("/public", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Public access"))
    })

    return r
}

どちらの例でも、 Use() メソッド（Gin）または r.Use() と r.Group() （Chi）により、簡単な構成が可能であることがわかります。期待される順序でミドルウェア関数をリストするだけです。順序は非常に重要です。各ミドルウェアはリクエストを順番に処理します。

実世界での応用：JWT認証ミドルウェア

両方のフレームワークで、より完全で再利用可能な JWTAuthMiddleware を例示します。

Gin JWTミドルウェア:

package middleware

import (
    "net/http"
    "strings"
    "time"

    "github.com/dgrijalva/jwt-go"
    "github.com/gin-gonic/gin"
)

// claims はJWTクレーム構造を表します
type Claims struct {
    UserID string `json:"user_id"`
    jwt.StandardClaims
}

// JWTAuthMiddleware はJWT認証のためのGinミドルウェアを作成します。
func JWTAuthMiddleware(secretKey string) gin.HandlerFunc {
    return func(c *gin.Context) {
        // Authorizationヘッダーからトークンを抽出
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Authorization header required"})
            return
        }

        tokenParts := strings.Split(authHeader, " ")
        if len(tokenParts) != 2 || tokenParts[0] != "Bearer" {
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid Authorization header format"})
            return
        }

        tokenString := tokenParts[1]

        // トークンを解析して検証
        token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
            return []byte(secretKey), nil
        })

        if err != nil {
            if err == jwt.ErrSignatureInvalid {
                c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid token signature"})
                return
            }
            if ve, ok := err.(*jwt.ValidationError); ok {
                if ve.Errors&jwt.ValidationErrorExpired != 0 {
                    c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Token expired"})
                    return
                }
            }
            c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "Could not parse token"})
            return
        }

        if !token.Valid {
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
            return
        }

        claims, ok := token.Claims.(*Claims)
        if !ok {
            c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": "Failed to get token claims"})
            return
        }

        // 後続のハンドラーのためにユーザーIDをコンテキストに保存
        c.Set("userID", claims.UserID)
        c.Next()
    }
}

Chi JWTミドルウェア:

package middleware

import (
    "context"
    "net/http"
    "strings"
    "time"

    "github.com/dgrijalva/jwt-go"
)

// claims はJWTクレーム構造を表します
type Claims struct {
    UserID string `json:"user_id"`
    jwt.StandardClaims
}

// UserID を保存するためのコンテキストキーを定義
type ContextKey string
const UserIDKey ContextKey = "userID"

// JWTAuthMiddleware はJWT認証のためのChiミドルウェアを作成します。
func JWTAuthMiddleware(secretKey string) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            authHeader := r.Header.Get("Authorization")
            if authHeader == "" {
                http.Error(w, "Authorization header required", http.StatusUnauthorized)
                return
            }

            tokenParts := strings.Split(authHeader, " ")
            if len(tokenParts) != 2 || tokenParts[0] != "Bearer" {
                http.Error(w, "Invalid Authorization header format", http.StatusUnauthorized)
                return
            }

            tokenString := tokenParts[1]

            token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
                return []byte(secretKey), nil
            })

            if err != nil {
                if err == jwt.ErrSignatureInvalid {
                    http.Error(w, "Invalid token signature", http.StatusUnauthorized)
                    return
                }
                if ve, ok := err.(*jwt.ValidationError); ok {
                    if ve.Errors&jwt.ValidationErrorExpired != 0 {
                        http.Error(w, "Token expired", http.StatusUnauthorized)
                        return
                    }
                }
                http.Error(w, "Could not parse token", http.StatusForbidden)
                return
            }

            if !token.Valid {
                http.Error(w, "Invalid token", http.StatusUnauthorized)
                return
            }

            claims, ok := token.Claims.(*Claims)
            if !ok {
                http.Error(w, "Failed to get token claims", http.StatusInternalServerError)
                return
            }

            // 後続のハンドラーのためにユーザーIDをコンテキストに保存
            ctx := context.WithValue(r.Context(), UserIDKey, claims.UserID)
            next.ServeHTTP(w, r.WithContext(ctx))
        })
    }
}

これらの例は、ロジックがどれほど似ているかを示していますが、フレームワークのコンテキストとのやり取りや、次のハンドラーへの制御の渡し方が異なります。どちらも、構成可能で再利用可能な認証を実現する上で同様に強力です。

結論

効果的なミドルウェアを作成することは、スケーラブルで保守性の高いGo Webアプリケーションを構築する上で基本です。コアコンセプトを理解し、GinやChiのようなフレームワークが提供するパターンを活用することで、開発者は横断的な懸念事項をエレガントに処理するモジュール式で再利用可能で構成可能なミドルウェアを作成でき、よりクリーンなコードとより効率的な開発ワークフローにつながります。ミドルウェアを活用してAPI開発を効率化し、堅牢なサービスを構築しましょう。

Share this article

HackerNews

More Posts from Leapcell

cover

Go Webハンドラーにおけるデータ整合性の確保

cover

GoにおけるPASETOによるAPIセキュリティの強化

Popular Posts