GoのAPIで標準ライブラリを使うべきか、フレームワークを使うべきか？

標準ライブラリ（net/http）は多くのユースケースで十分に強力であり、完全な制御と最小限の依存関係を提供します。高速な開発、組み込みミドルウェア、または便利なルーティング機能が必要な場合は、GinやChiなどのフレームワークを使用してください。複雑さが生じるまで標準ライブラリから始め、必要に応じてフレームワークへの移行を行ってください。

GoのAPIプロジェクトを構成する最佳な方法は何か？

ハンドラ、サービス、リポジトリ、モデルそれぞれを別々のパッケージに分けて、階層構造を採用しましょう。よく使われるパターンには、ハーキュラルアーキテクチャやクリーンアーキテクチャがあります。ビジネスロジックをHTTPハンドラやデータベースの実装から独立させることで、テスト性や保守性が向上します。

GoのAPIで認証をどのように処理すればよいですか？

一般的なアプローチとしては、ステートレス認証にJWTトークンを使用し、サードパーティとの統合にはOAuth2を、サービス間通信にはAPIキーを用いる方法があります。認証は、ハンドラに到達する前に資格情報を検証するミドルウェアとして実装してください。パスワードなどの機密データは、bcryptハッシュ化を使用して保存してください。

GoでAPIバージョニングの推奨されるアプローチはどのようなものですか？

URLパスバージョニング（例：/api/v1/users）を使用するようにしてください。これは明確で理解しやすいからです。代替として、URLがよりすっきりと見えるようにヘッダーに基づくバージョニングも利用できます。可能な限り破壊的変更を避けてください。また、バージョン間で後方互換性を維持してください。非推奨になるスケジュールは明確に文書化してください。

GoのAPIでエラーを処理するにはどうすればよいですか？

一貫したフォーマットで構造化されたエラーレスポンスを返し、エラーコード、メッセージ、およびオプションの詳細情報を含めること。異なるエラーカテゴリを区別するためにカスタムのエラータイプを使用すること。パニックを捕獲し、エラーをログに記録するためのエラーハンドリングミドルウェアを実装すること。本番環境ではクライアントに内部のエラーデータを公開してはならない。

GoのAPIに対して最も効果的なテスト戦略はどれですか？

ビジネスロジックにはユニットテスト、データベース操作には統合テスト、完全なAPIワークフローにはエンドツーエンドテストを実装してください。サーバーを起動せずにHTTPハンドラをテストするには、httptestパッケージを使用してください。外部依存関係やデータベースをモックしてください。重要なパスの高カバレッジを目指してください。

GoでREST APIを構築する：完全ガイド

Goの堅牢なエコシステムを使って、本番環境に適したREST APIを構築しましょう。

高性能な REST APIの構築（Goを使用）は、Google、Uber、Dropbox、そして多数のスタートアップでシステムを動かすための標準的なアプローチとなっています。

Goのシンプルさ、強力な並行処理のサポート、そして高速なコンパイルにより、マイクロサービスやバックエンド開発に最適です。

go api この素晴らしい画像は、FLUX.1-Kontext-dev: Image Augmentation AI Model によって生成されました。

API開発にGoを選ぶ理由

GoはAPI開発においていくつかの魅力的な利点を提供します：

パフォーマンスと効率性：Goはネイティブマシンコードにコンパイルされ、Cに近いパフォーマンスを提供しますが、複雑さは伴いません。効率的なメモリ管理と小さなバイナリサイズにより、コンテナ化されたデプロイメントに最適です。

組み込みの並行処理：Goroutinesとチャネルにより、数千の並行リクエストを簡単に処理できます。複雑なスレッドコードを使用することなく、複数の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でデータベース操作に取り組む際には、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(),
    }
    
    // サーバーをgoroutineで起動
    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が他のウェブサイトからデータを集約する必要がある場合、Go用のBeautiful Soupの代替を理解することで、堅牢なウェブスクレイピング機能を実装できます。

ドキュメント生成

多くのAPIはドキュメントを生成する必要があります。GoでPDFを生成するには、いくつかのライブラリとアプローチがAPIエンドポイントに統合できます。

セマンティック検索とリランキング

テキスト検索と取得に取り組むAPIでは、埋め込みモデルを使用したリランキングを実装することで、検索結果の関連性を大幅に向上させることができます。

MCPサーバーの構築

Model Context Protocolに従ってAPIを実装している場合、GoでMCPサーバーの実装のガイドを参照してください。これはプロトコル仕様と実用的な実装をカバーしています。

一般的な落とし穴と解決策

コンテキストを適切に使用しないこと

常にコールチェーン全体でコンテキストを渡して尊重してください。これにより、適切なキャンセルとタイムアウト処理が可能になります。

ゴルーチンリークを無視すること

すべてのゴルーチンが終了できるようにしてください。デッドライン付きのコンテキストを使用し、常に終了の合図を送る方法があるようにしてください。

責任のないエラーハンドリング

クライアントに直接データベースエラーを返さないでください。エラーをコンテキストでラップし、API応答にサニタイズされたメッセージを返してください。

入力検証の欠如

すべての入力を境界で検証してください。認証済みユーザーからのデータでも信頼しないでください。

不十分なテスト

ハッピーなパスだけをテストしないでください。エラーケース、エッジケース、並行アクセスのシナリオをカバーしてください。

ベストプラクティスの概要

シンプルから始めましょう：最初は標準ライブラリから始め、複雑さが要求する場合にフレームワークを追加してください。
アプリケーションをレイヤー化してください：HTTPハンドラ、ビジネスロジック、データアクセスを分離して維持性を向上させます。
すべてを検証してください：境界ですべての入力を検証してください。強力な型付けと検証ライブラリを使用してください。
エラーを一貫して処理してください：構造化されたエラーレスポンスを返してください。内部エラーはログに記録しますが、公開しないでください。
ミドルウェアを使用してください：認証、ロギング、メトリクスなどのクロスカット的な関心事をミドルウェアとして実装してください。
徹底的にテストしてください：ロジックの単体テスト、データアクセスの統合テスト、ワークフローのエンドトゥーエンドテストを書くようにしてください。
APIをドキュメント化してください：インタラクティブなドキュメント化のためにOpenAPI/Swaggerを使用してください。
生産環境でモニタリングしてください：構造化されたロギング、メトリクス収集、ヘルスチェックを実装してください。
慎重に最適化してください：最適化する前にプロファイリングしてください。キャッシュ、接続プール、圧縮が有益な場所で使用してください。
グレースフルシャットダウンを設計してください：終了シグナルを適切に処理し、接続を適切にドレインしてください。

スタートチェックリスト

Goプロジェクトで作業する際の参考として、包括的なGoチートシートを手元に置くことで、開発を速め、構文と一般的なパターンのクイックリファレンスとして役立ちます。

最初のGo APIを構築する準備はできましたか？以下の手順から始めましょう：

✅ Go環境とプロジェクト構造をセットアップ
✅ 標準ライブラリまたはフレームワークを選択
✅ 基本的なCRUDエンドポイントを実装
✅ リクエスト検証とエラーハンドリングを追加
✅ 認証ミドルウェアを実装
✅ 接続プールを使用したデータベース統合を実装
✅ ユニットテストと統合テストを書く
✅ APIドキュメントを追加
✅ ロギングとメトリクスを実装
✅ Dockerでコンテナ化
✅ CI/CDパイプラインを設定
✅ モニタリング付きで本番環境にデプロイ

結論

Goは、パフォーマンス、シンプルさ、そして堅牢なツールチェーンを組み合わせることで、REST APIの構築に優れた基盤を提供します。マイクロサービス、内部ツール、またはパブリックAPIを構築する際に関係なく、Goのエコシステムにはあらゆる要件に対応した成熟したソリューションがあります。

成功の鍵は、堅牢なアーキテクチャパターンから始め、最初から適切なエラーハンドリングと検証を実装し、包括的なテストカバレッジを構築することです。APIが成長するにつれて、Goのパフォーマンス特性と強力な並行性サポートが役立ちます。

API開発は反復的なプロセスであることを思い出してください。最初は最小限の実装から始め、フィードバックを収集し、現実世界での使用パターンに基づいてアプローチを改善してください。Goの高速なコンパイルとシンプルなリファクタリングにより、この反復サイクルはスムーズかつ生産的になります。

有用なリンク

外部リソース

公式ドキュメント

Go公式ドキュメント - Goの公式ドキュメントおよびチュートリアル
Go net/httpパッケージ - 標準ライブラリのHTTPパッケージドキュメント
Effective Go - 明確で、Goに合ったコードを書くためのベストプラクティス

テストと開発ツール

Testify - 普通のアサーションとモックを含むツールキット
httptestパッケージ - HTTPテスト用の標準ライブラリユーティリティ
Swaggo - RESTful APIドキュメントを自動生成
Air - 開発中のGoアプリケーション用のライブリロード

ベストプラクティスとガイド

Goプロジェクトレイアウト - 標準的なGoプロジェクトレイアウト
Uber Goスタイルガイド - Uberから提供される包括的なGoスタイルガイド
Goコードレビューのコメント - Goコードレビュー中に一般的にされるコメント
REST API設計のベストプラクティス - 一般的なREST API設計の原則

セキュリティと認証

OWASP Goセキュアコーディング実践ガイド - Goアプリケーション向けのセキュリティガイドライン
Go用OAuth2 - OAuth 2.0実装
bcryptパッケージ - パスワードハッシュ化実装

パフォーマンスと監視

pprof - Goプログラム用の組み込みプロファイリングツール
Prometheusクライアント - Go用のPrometheusインストゥルメンテーションライブラリ
Zapロガー - 高速で構造化された、レベル付きのロギング