Go言語（Golang）のgRPCでバックエンドAPIを開発する方法まとめ

package sample

import (
    "os"
)

// インターフェース定義
type SampleRepository interface {
    Hello() string
}

// 構造体定義
type sampleRepository struct{}

// インスタンス生成用関数
func NewSampleRepository() SampleRepository {
    return &sampleRepository{}
}

// メソッド定義
func (r *sampleRepository) Hello() string {
    env := os.Getenv("ENV")

    res := "Hello World !!"
    if env == "testing" {
        res = "Testing Hello World !!"
    }

    return res
}

package sample

import (
    "fmt"

    "go-grpc/internal/repositories/sample"
)

// インターフェース定義
type SampleService interface {
    Sample() (string, error)
}

// 構造体定義
type sampleService struct {
    sampleRepository sample.SampleRepository
}

// インスタンス生成用関数
func NewSampleService(
    sampleRepository sample.SampleRepository,
) SampleService {
    return &sampleService{
        sampleRepository: sampleRepository,
    }
}

func (s *sampleService) Sample() (string, error) {
    text := s.sampleRepository.Hello()
    if text == "" {
        return "", fmt.Errorf("textが空です。")
    }

    return text, nil
}

package sample

import (
    "context"

    serviceSample "go-grpc/internal/services/sample"
    pb "go-grpc/pb/sample"
)

// インターフェースの定義
type SampleHelloUsecase interface {
    Exec(ctx context.Context, in *pb.Empty) (*pb.HelloResponseBody, error)
}

// 構造体の定義
type sampleHelloUsecase struct {
    sampleService serviceSample.SampleService
}

// インスタンス生成用関数の定義
func NewSampleHelloUsecase(
    sampleService serviceSample.SampleService,
) SampleHelloUsecase {
    return &sampleHelloUsecase{
        sampleService: sampleService,
    }
}

func (u *sampleHelloUsecase) Exec(ctx context.Context, in *pb.Empty) (*pb.HelloResponseBody, error) {
    text, err := u.sampleService.Sample()
    if err != nil {
        return nil, err
    }

    return &pb.HelloResponseBody{Message: text}, nil
}

package sample

import (
    "context"
    "testing"

    repoSample "go-grpc/internal/repositories/sample"
    mockRepoSample "go-grpc/internal/repositories/sample/mock_sample"
    serviceSample "go-grpc/internal/services/sample"
    pb "go-grpc/pb/sample"

    "github.com/stretchr/testify/assert"
    "go.uber.org/mock/gomock"
)

func TestSampleHelloOK(t *testing.T) {
    // ユースケースのインスタンス化
    sampleRepository := repoSample.NewSampleRepository()
    sampleService := serviceSample.NewSampleService(sampleRepository)
    sampleUsecase := NewSampleHelloUsecase(sampleService)

    // パラメータ設定
    ctx := context.Background()
    in := &pb.Empty{}

    // テストの実行
    res, err := sampleUsecase.Exec(ctx, in)

    // 検証
    assert.Equal(t, "Testing Hello World !!", res.Message)
    assert.Equal(t, nil, err)
}

func TestSampleHelloErr(t *testing.T) {
    // リポジトリのモック化
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()
    mockSampleRepository := mockRepoSample.NewMockSampleRepository(ctrl)
    mockSampleRepository.EXPECT().Hello().Return("")

    // ユースケースのインスタンス化
    sampleService := serviceSample.NewSampleService(mockSampleRepository)
    sampleUsecase := NewSampleHelloUsecase(sampleService)

    // パラメータ設定
    ctx := context.Background()
    in := &pb.Empty{}

    // テストの実行
    res, err := sampleUsecase.Exec(ctx, in)

    // 検証
    assert.Equal(t, "", res.GetMessage())
    assert.NotEqual(t, nil, err)
}

package sample

import (
    "context"
    "fmt"

    pb "go-grpc/pb/sample"

    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

// インターフェースの定義
type SampleHelloAddTextUsecase interface {
    Exec(ctx context.Context, in *pb.HelloAddTextRequestBody) (*pb.HelloAddTextResponseBody, error)
}

// 構造体の定義
type sampleHelloAddTextUsecase struct{}

// インスタンス生成用関数の定義
func NewSampleHelloAddTextUsecase() SampleHelloAddTextUsecase {
    return &sampleHelloAddTextUsecase{}
}

func (u *sampleHelloAddTextUsecase) Exec(ctx context.Context, in *pb.HelloAddTextRequestBody) (*pb.HelloAddTextResponseBody, error) {
    // バリデーションチェック
    if err := in.Validate(); err != nil {
        return nil, status.Errorf(codes.InvalidArgument, "%s", err.Error())
    }

    msg := fmt.Sprintf("Hello %s", in.Text)

    return &pb.HelloAddTextResponseBody{Message: msg}, nil
}

package sample

import (
    "context"
    "fmt"
    "os"
    "testing"

    pb "go-grpc/pb/sample"

    "github.com/stretchr/testify/assert"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    "google.golang.org/grpc/metadata"
)

// カバレッジの対象から除外
func TestExcludeFromCoverage(t *testing.T) {
    s := NewSample()
    _, _ = s.Hello(context.Background(), &pb.Empty{})
    _, _ = s.HelloAddText(context.Background(), &pb.HelloAddTextRequestBody{Text: "Add World !"})
}

func TestSampleHello(t *testing.T) {
    // gRPCクライアントの設定
    grpcPort := os.Getenv("GRPC_PORT")
    if grpcPort == "" {
        grpcPort = "50051"
    }
    target := fmt.Sprintf("dns:///localhost:%s", grpcPort)
    conn, err := grpc.NewClient(target, grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        t.Fatalf("Failed to connect: %v", err)
    }
    defer conn.Close()
    client := pb.NewSampleServiceClient(conn)

    // テストの実行
    res, err := client.Hello(context.Background(), &pb.Empty{})
    if err != nil {
        t.Fatalf("Failed to call Hello: %v", err)
    }

    // 検証
    assert.Equal(t, "Testing Hello World !!", res.Message)
}

func TestSampleHelloAddText(t *testing.T) {
    // gRPCクライアントの設定
    grpcPort := os.Getenv("GRPC_PORT")
    if grpcPort == "" {
        grpcPort = "50051"
    }
    target := fmt.Sprintf("dns:///localhost:%s", grpcPort)
    conn, err := grpc.NewClient(target, grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        t.Fatalf("Failed to connect: %v", err)
    }
    defer conn.Close()
    client := pb.NewSampleServiceClient(conn)

    // メタデータにauthorizationを追加
    ctx := context.Background()
    md := metadata.New(map[string]string{"authorization": "Bearer token"})
    ctx = metadata.NewOutgoingContext(ctx, md)

    // テストの実行
    res, err := client.HelloAddText(ctx, &pb.HelloAddTextRequestBody{Text: "Add World !"})
    if err != nil {
        t.Fatalf("Failed to call HelloAddText: %v", err)
    }

    // 検証
    assert.Equal(t, "Hello Add World !", res.Message)
}

package main

import (
    "fmt"
    "log/slog"
    "net"
    "os"

    sGrpcSample "go-grpc/internal/servers/grpc/sample"
    pbSample "go-grpc/pb/sample"

    "github.com/joho/godotenv"
    "google.golang.org/grpc"
    "google.golang.org/grpc/reflection"
)

func main() {
    // .env ファイルの読み込み
    err := godotenv.Load()
    if err != nil {
        slog.Error(fmt.Sprintf(".envファイルの読み込みに失敗しました。: %v", err))
    }

    // ENVの設定
    env := os.Getenv("ENV")
    if env == "" {
        env = "local"
    }

    // gRPC用のポート番号の設定
    grpcPort := os.Getenv("GRPC_PORT")
    if grpcPort == "" {
        grpcPort = "50051"
    }

    // Listenerの設定
    listener, err := net.Listen("tcp", fmt.Sprintf(":%s", grpcPort))
    if err != nil {
        slog.Error(fmt.Sprintf("Listenerの設定に失敗しました。: %v", err))
    }

    // gRPCサーバーの作成
    s := grpc.NewServer()

    // サービス設定
    pbSample.RegisterSampleServiceServer(s, sGrpcSample.NewSample())

    // リフレクション設定
    reflection.Register(s)

    // gRPCサーバーの起動（非同期）
    slog.Info(fmt.Sprintf("[ENV=%s] start gRPC-Server port: %s", env, grpcPort))
    if err := s.Serve(listener); err != nil {
        slog.Error(fmt.Sprintf("gRPC-Server の起動に失敗しました。: %v", err))
    }
}

package context

type contextKey string

const (
    XRequestId contextKey = "x-request-id"
    XRequestSource contextKey = "x-request-source"
    XUid contextKey = "x-uid"
    Status contextKey = "status"
    StatusCode contextKey = "statusCode"
)

package logger

import (
    "context"
    "log/slog"
    "os"

    utilCtx "go-grpc/internal/util/context"
)

type SlogHandler struct {
    slog.Handler
}

func (h *SlogHandler) Handle(ctx context.Context, r slog.Record) error {
    requestId, ok := ctx.Value(utilCtx.XRequestId).(string)
    if ok {
        r.AddAttrs(slog.Attr{Key: "requestId", Value: slog.String("requestId", requestId).Value})
    }

    requestSource, ok := ctx.Value(utilCtx.XRequestSource).(string)
    if ok {
        r.AddAttrs(slog.Attr{Key: "requestSource", Value: slog.String("requestSource", requestSource).Value})
    }

    uid, ok := ctx.Value(utilCtx.XUid).(string)
    if ok {
        r.AddAttrs(slog.Attr{Key: "uid", Value: slog.String("uid", uid).Value})
    }

    status, ok := ctx.Value(utilCtx.Status).(string)
    if ok {
        r.AddAttrs(slog.Attr{Key: "status", Value: slog.String("status", status).Value})
    }

    statusCode, ok := ctx.Value(utilCtx.StatusCode).(string)
    if ok {
        r.AddAttrs(slog.Attr{Key: "statusCode", Value: slog.String("statusCode", statusCode).Value})
    }

    return h.Handler.Handle(ctx, r)
}

var slogHandler = &SlogHandler{
    slog.NewTextHandler(os.Stdout, nil),
}

var logger = slog.New(slogHandler)

func Info(ctx context.Context, message string) {
    env := os.Getenv("ENV")
    if env != "testing" {
        logger.InfoContext(ctx, message)
    }
}

func Warn(ctx context.Context, message string) {
    env := os.Getenv("ENV")
    if env != "testing" {
        logger.WarnContext(ctx, message)
    }
}

func Error(ctx context.Context, message string) {
    env := os.Getenv("ENV")
    if env != "testing" {
        logger.ErrorContext(ctx, message)
    }
}

package sample

import (
    "context"
    "fmt"

    "go-grpc/internal/util/logger"
    pb "go-grpc/pb/sample"

    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

// インターフェースの定義
type SampleHelloAddTextUsecase interface {
    Exec(ctx context.Context, in *pb.HelloAddTextRequestBody) (*pb.HelloAddTextResponseBody, error)
}

// 構造体の定義
type sampleHelloAddTextUsecase struct{}

// インスタンス生成用関数の定義
func NewSampleHelloAddTextUsecase() SampleHelloAddTextUsecase {
    return &sampleHelloAddTextUsecase{}
}

func (u *sampleHelloAddTextUsecase) Exec(ctx context.Context, in *pb.HelloAddTextRequestBody) (*pb.HelloAddTextResponseBody, error) {
    // バリデーションチェック
    if err := in.Validate(); err != nil {
        msg := fmt.Sprintf("バリデーションエラー：%s", err.Error())
        logger.Warn(ctx, msg)
        return nil, status.Errorf(codes.InvalidArgument, "%s", err.Error())
    }

    msg := fmt.Sprintf("Hello %s", in.Text)

    return &pb.HelloAddTextResponseBody{Message: msg}, nil
}

package interceptor

import (
    "context"
    "fmt"
    "strings"

    utilCtx "go-grpc/internal/util/context"
    "go-grpc/internal/util/logger"
    pb "go-grpc/pb/sample"

    "github.com/google/uuid"
    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/metadata"
    "google.golang.org/grpc/status"
)

// Streamでコンテキストを共有させるためのラッパー構造体（対象メソッドのオーバーライド）
type wrappedServerStream struct {
    grpc.ServerStream
    ctx context.Context
}

func (w *wrappedServerStream) SendMsg(m interface{}) error {
    return w.ServerStream.SendMsg(m)
}
func (w *wrappedServerStream) Context() context.Context {
    return w.ctx
}

// リクエスト用のUnaryインターセプター
func RequestUnaryInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    // ctxにx-request-idを設定
    requestId := uuid.New().String()
    ctx = context.WithValue(ctx, utilCtx.XRequestId, requestId)

    // レスポンスのメタデータにx-request-idを追加
    headerMD := metadata.New(map[string]string{string(utilCtx.XRequestId): requestId})
    if err := grpc.SetHeader(ctx, headerMD); err != nil {
        return nil, err
    }

    // メタデータを取得
    md, ok := metadata.FromIncomingContext(ctx)
    if !ok {
        return nil, fmt.Errorf("メタデータを取得できません。")
    }

    // リクエストのメタデータからx-request-sourceを取得
    requestSource, ok := md[string(utilCtx.XRequestSource)]
    if !ok {
        requestSource = []string{"-"}
    }

    // ctxにx-request-sourceを設定
    ctx = context.WithValue(ctx, utilCtx.XRequestSource, requestSource[0])

    // レスポンスのメタデータにx-request-sourceを追加
    headerMD2 := metadata.New(map[string]string{string(utilCtx.XRequestSource): requestSource[0]})
    if err := grpc.SetHeader(ctx, headerMD2); err != nil {
        return nil, err
    }

    // リクエスト開始のログ出力
    logger.Info(ctx, "start gRPC-Server request")

    // 処理を実行
    res, err := handler(ctx, req)

    // ステータスコードを取得
    st, ok := status.FromError(err)
    if !ok {
        return nil, fmt.Errorf("ステータスコードを取得できませんでした。")
    }

    // ctxにstatusとstatusCodeを設定
    ctx = context.WithValue(ctx, utilCtx.Status, st.Code().String())
    ctx = context.WithValue(ctx, utilCtx.StatusCode, fmt.Sprintf("%d", int(st.Code())))

    // トレーラーに情報追加
    if err != nil {
        tStatus := metadata.New(map[string]string{"status": fmt.Sprintf("ERROR ( %d %s )", int(st.Code()), st.Code().String())})
        if err := grpc.SetTrailer(ctx, tStatus); err != nil {
            return nil, err
        }
    } else {
        tStatus := metadata.New(map[string]string{"status": fmt.Sprintf("SUCCESS ( %d %s )", int(st.Code()), st.Code().String())})
        if err := grpc.SetTrailer(ctx, tStatus); err != nil {
            return nil, err
        }
    }

    // リクエスト終了のログ出力
    logger.Info(ctx, "finish gRPC-Server request")

    return res, err
}

// リクエスト用のStreamインターセプター
func RequestStreamInterceptor(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
    // ctxにx-request-idを設定
    requestId := uuid.New().String()
    ctx := ss.Context()
    ctx = context.WithValue(ctx, utilCtx.XRequestId, requestId)

    // レスポンスのメタデータにx-request-idを追加
    headerMD := metadata.New(map[string]string{string(utilCtx.XRequestId): requestId})
    if err := grpc.SetHeader(ctx, headerMD); err != nil {
        return err
    }

    // メタデータを取得
    md, ok := metadata.FromIncomingContext(ctx)
    if !ok {
        return fmt.Errorf("メタデータを取得できません。")
    }

    // リクエストのメタデータからx-request-sourceを取得
    requestSource, ok := md[string(utilCtx.XRequestSource)]
    if !ok {
        requestSource = []string{"-"}
    }

    // ctxにx-request-sourceを設定
    ctx = context.WithValue(ctx, utilCtx.XRequestSource, requestSource[0])

    // レスポンスのメタデータにx-request-sourceを追加
    headerMD2 := metadata.New(map[string]string{string(utilCtx.XRequestSource): requestSource[0]})
    if err := grpc.SetHeader(ctx, headerMD2); err != nil {
        return err
    }

    // リクエスト開始のログ出力
    logger.Info(ctx, "start gRPC-Server stream request")

    err := handler(srv, &wrappedServerStream{ss, ctx})

    // ステータスコードを取得
    st, ok := status.FromError(err)
    if !ok {
        return fmt.Errorf("ステータスコードを取得できませんでした。")
    }

    // ctxにstatusとstatusCodeを設定
    ctx = context.WithValue(ctx, utilCtx.Status, st.Code().String())
    ctx = context.WithValue(ctx, utilCtx.StatusCode, fmt.Sprintf("%d", int(st.Code())))

    // トレーラーに情報追加
    if err != nil {
        tStatus := metadata.New(map[string]string{"status": fmt.Sprintf("ERROR ( %d %s )", int(st.Code()), st.Code().String())})
        if err := grpc.SetTrailer(ctx, tStatus); err != nil {
            return err
        }
    } else {
        tStatus := metadata.New(map[string]string{"status": fmt.Sprintf("SUCCESS ( %d %s )", int(st.Code()), st.Code().String())})
        if err := grpc.SetTrailer(ctx, tStatus); err != nil {
            return err
        }
    }

    // リクエスト終了のログ出力
    logger.Info(ctx, "finish gRPC-Server stream request")

    return err
}

// 認証用のUnaryインターセプター
func AuthUnaryInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    // 対象外のメソッドを設定
    skipMethods := []string{
        pb.SampleService_Hello_FullMethodName,
    }

    // 対象外メソッドの場合はスキップ
    for _, method := range skipMethods {
        if info.FullMethod == method {
            return handler(ctx, req)
        }
    }

    // authorizationからトークンを取得
    md, ok := metadata.FromIncomingContext(ctx)
    if !ok {
        logger.Error(ctx, "メタデータを取得できません。")
        return nil, fmt.Errorf("メタデータを取得できません。")
    }
    authHeader, ok := md["authorization"]
    if !ok {
        logger.Warn(ctx, "認証用トークンが設定されていません。")
        return nil, status.Errorf(codes.InvalidArgument, "%s", "認証用トークンが設定されていません。")
    }
    token := strings.TrimPrefix(authHeader[0], "Bearer ")
    if token == "" {
        logger.Warn(ctx, "認証用トークンが設定されていません。")
        return nil, status.Errorf(codes.InvalidArgument, "%s", "認証用トークンが設定されていません。")
    }

    // TODO: 認証チェック処理を追加

    // 処理を実行
    return handler(ctx, req)
}

// 認証用のStreamインターセプター
func AuthStreamInterceptor(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
    // 対象外のメソッドを設定
    skipMethods := []string{
    }

    // 対象外メソッドの場合はスキップ
    for _, method := range skipMethods {
        if info.FullMethod == method {
            return handler(srv, ss)
        }
    }

    // authorizationからトークンを取得
    ctx := ss.Context()
    md, ok := metadata.FromIncomingContext(ctx)
    if !ok {
        logger.Error(ctx, "メタデータを取得できません。")
        return fmt.Errorf("メタデータを取得できません。")
    }
    authHeader, ok := md["authorization"]
    if !ok {
        logger.Warn(ctx, "認証用トークンが設定されていません。")
        return status.Errorf(codes.InvalidArgument, "%s", "認証用トークンが設定されていません。")
    }
    token := strings.TrimPrefix(authHeader[0], "Bearer ")
    if token == "" {
        logger.Warn(ctx, "認証用トークンが設定されていません。")
        return status.Errorf(codes.InvalidArgument, "%s", "認証用トークンが設定されていません。")
    }

    // TODO: 認証チェック処理を追加

    return handler(srv, &wrappedServerStream{ss, ctx})
}

package main

import (
    "fmt"
    "log/slog"
    "net"
    "os"

    "go-grpc/internal/interceptor"
    sGrpcSample "go-grpc/internal/servers/grpc/sample"
    pbSample "go-grpc/pb/sample"

    "github.com/joho/godotenv"
    "google.golang.org/grpc"
    "google.golang.org/grpc/reflection"
)

func main() {
    // .env ファイルの読み込み
    err := godotenv.Load()
    if err != nil {
        slog.Error(fmt.Sprintf(".envファイルの読み込みに失敗しました。: %v", err))
    }

    // ENVの設定
    env := os.Getenv("ENV")
    if env == "" {
        env = "local"
    }

    // gRPC用のポート番号の設定
    grpcPort := os.Getenv("GRPC_PORT")
    if grpcPort == "" {
        grpcPort = "50051"
    }

    // Listenerの設定
    listener, err := net.Listen("tcp", fmt.Sprintf(":%s", grpcPort))
    if err != nil {
        slog.Error(fmt.Sprintf("Listenerの設定に失敗しました。: %v", err))
    }

    // gRPCサーバーの作成
    s := grpc.NewServer(
        // インターセプターの適用
        grpc.ChainUnaryInterceptor(
            interceptor.RequestUnaryInterceptor,
            interceptor.AuthUnaryInterceptor,
        ),
        grpc.ChainStreamInterceptor(
            interceptor.RequestStreamInterceptor,
            interceptor.AuthStreamInterceptor,
        ),
    )

    // サービス設定
    pbSample.RegisterSampleServiceServer(s, sGrpcSample.NewSample())

    // リフレクション設定
    reflection.Register(s)

    // gRPCサーバーの起動（非同期）
    slog.Info(fmt.Sprintf("[ENV=%s] start gRPC-Server port: %s", env, grpcPort))
    if err := s.Serve(listener); err != nil {
        slog.Error(fmt.Sprintf("gRPC-Server の起動に失敗しました。: %v", err))
    }
}

package sample

import (
    "fmt"
    "time"

    "go-grpc/internal/util/logger"
    pb "go-grpc/pb/sample"

    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

// インターフェースの定義
type SampleHelloServerStreamUsecase interface {
    Exec(in *pb.HelloServerStreamRequestBody, stream grpc.ServerStreamingServer[pb.HelloServerStreamResponseBody]) error
}

// 構造体の定義
type sampleHelloServerStreamUsecase struct{}

// インスタンス生成用関数の定義
func NewSampleHelloServerStreamUsecase() SampleHelloServerStreamUsecase {
    return &sampleHelloServerStreamUsecase{}
}

func (u *sampleHelloServerStreamUsecase) Exec(in *pb.HelloServerStreamRequestBody, stream grpc.ServerStreamingServer[pb.HelloServerStreamResponseBody]) error {
    // コンテキストを取得
    ctx := stream.Context()

    // バリデーションチェック
    if err := in.Validate(); err != nil {
        msg := fmt.Sprintf("バリデーションエラー：%s", err.Error())
        logger.Warn(ctx, msg)

        return status.Errorf(codes.InvalidArgument, "%s", err.Error())
    }

    resCount := 3
    for i := 0; i < resCount; i++ {
        if err := stream.Send(
            &pb.HelloServerStreamResponseBody{
                Message: fmt.Sprintf("[%d]Hello, %s", i, in.GetText()),
            },
        ); err != nil {
            return err
        }
        time.Sleep(time.Second * 1)
    }

    return nil
}

package sample

import (
    "context"
    "fmt"
    "testing"

    pb "go-grpc/pb/sample"

    "github.com/stretchr/testify/assert"
    "google.golang.org/grpc"
)

// HelloServerStreamのstream用のモック構造体
type mockHelloServerStream struct {
    grpc.ServerStreamingServer[pb.HelloServerStreamResponseBody]
    ctx context.Context
    sent []*pb.HelloServerStreamResponseBody
    sendErr error
}

func (m *mockHelloServerStream) Send(resp *pb.HelloServerStreamResponseBody) error {
    m.sent = append(m.sent, resp)
    return m.sendErr
}

func (m *mockHelloServerStream) Context() context.Context {
    return m.ctx
}

func TestSampleHelloServerStreamOK(t *testing.T) {
    // ユースケースのインスタンス化
    sampleUsecase := NewSampleHelloServerStreamUsecase()

    // パラメータの設定
    in := &pb.HelloServerStreamRequestBody{Text: "World !"}
    mockStream := &mockHelloServerStream{
        ctx: context.Background(),
        sent: []*pb.HelloServerStreamResponseBody{},
        sendErr: nil,
    }

    // テストの実行
    err := sampleUsecase.Exec(in, mockStream)

    // 検証
    assert.Equal(t, nil, err)
}

func TestSampleHelloServerStreamValidateErr(t *testing.T) {
    // ユースケースのインスタンス化
    sampleUsecase := NewSampleHelloServerStreamUsecase()

    // パラメータの設定
    in := &pb.HelloServerStreamRequestBody{Text: ""}
    mockStream := &mockHelloServerStream{
        ctx: context.Background(),
        sent: []*pb.HelloServerStreamResponseBody{},
        sendErr: nil,
    }

    // テストの実行
    err := sampleUsecase.Exec(in, mockStream)

    // 検証
    assert.NotEqual(t, nil, err)
}

func TestSampleHelloServerStreamSendErr(t *testing.T) {
    // ユースケースのインスタンス化
    sampleUsecase := NewSampleHelloServerStreamUsecase()

    // パラメータの設定
    in := &pb.HelloServerStreamRequestBody{Text: "World !"}
    mockStream := &mockHelloServerStream{
        ctx: context.Background(),
        sent: []*pb.HelloServerStreamResponseBody{},
        sendErr: fmt.Errorf("error"),
    }

    // テストの実行
    err := sampleUsecase.Exec(in, mockStream)

    // 検証
    assert.NotEqual(t, nil, err)
}

package sample

import (
    "errors"
    "fmt"
    "io"

    "go-grpc/internal/util/logger"
    pb "go-grpc/pb/sample"

    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

// インターフェースの定義
type SampleHelloClientStreamUsecase interface {
    Exec(stream grpc.ClientStreamingServer[pb.HelloClientStreamRequestBody, pb.HelloClientStreamResponseBody]) error
}

// 構造体の定義
type sampleHelloClientStreamUsecase struct{}

// インスタンス生成用関数の定義
func NewSampleHelloClientStreamUsecase() SampleHelloClientStreamUsecase {
    return &sampleHelloClientStreamUsecase{}
}

func (u *sampleHelloClientStreamUsecase) Exec(stream grpc.ClientStreamingServer[pb.HelloClientStreamRequestBody, pb.HelloClientStreamResponseBody]) error {
    // コンテキストを取得
    ctx := stream.Context()

    textList := make([]string, 0)
    for {
        req, err := stream.Recv()
        if errors.Is(err, io.EOF) {
            msg := fmt.Sprintf("Hello, %v!", textList)
           return stream.SendAndClose(&pb.HelloClientStreamResponseBody{Message: msg})
        }
        if err != nil {
            return err
        }

        // バリデーションチェック
        if err := req.Validate(); err != nil {
            msg := fmt.Sprintf("バリデーションエラー：%s", err.Error())
            logger.Warn(ctx, msg)

            return status.Errorf(codes.InvalidArgument, "%s", err.Error())
        }

        textList = append(textList, req.GetText())
    }
}

package sample

import (
    "context"
    "fmt"
    "io"
    "testing"

    pb "go-grpc/pb/sample"

    "github.com/stretchr/testify/assert"
    "google.golang.org/grpc"
)

// HelloClientStreamのstream用のモック構造体
type mockHelloClientStream struct {
    grpc.ClientStreamingServer[pb.HelloClientStreamRequestBody, pb.HelloClientStreamResponseBody]
    ctx context.Context
    recvData []*pb.HelloClientStreamRequestBody
    recvIndex int
    recvError error
    sendResult *pb.HelloClientStreamResponseBody
    sendError error
}

func (m *mockHelloClientStream) Recv() (*pb.HelloClientStreamRequestBody, error) {
    if m.recvError != nil {
        return nil, m.recvError
    }
    if m.recvIndex >= len(m.recvData) {
        return nil, io.EOF
    }
    data := m.recvData[m.recvIndex]
    m.recvIndex++
    return data, nil
}

func (m *mockHelloClientStream) SendAndClose(resp *pb.HelloClientStreamResponseBody) error {
    m.sendResult = resp
    return m.sendError
}

func (m *mockHelloClientStream) Context() context.Context {
    return m.ctx
}

func TestSampleHelloClientStreamOK(t *testing.T) {
    // ユースケースのインスタンス化
    sampleUsecase := NewSampleHelloClientStreamUsecase()

    // パラメータの設定
    mockClientStream := &mockHelloClientStream{
        ctx: context.Background(),
        recvData: []*pb.HelloClientStreamRequestBody{{Text: "A"}, {Text: "B"}, {Text: "C"}},
        recvError: nil,
        sendError: nil,
    }

    // テストの実行
    err := sampleUsecase.Exec(mockClientStream)

    // 検証
    assert.Equal(t, nil, err)
}

func TestSampleHelloClientStreamRecvErr(t *testing.T) {
    // ユースケースのインスタンス化
    sampleUsecase := NewSampleHelloClientStreamUsecase()

    // パラメータの設定
    mockClientStream := &mockHelloClientStream{
        ctx: context.Background(),
        recvData: []*pb.HelloClientStreamRequestBody{{Text: "A"}, {Text: "B"}, {Text: "C"}},
        recvError: fmt.Errorf("error"),
        sendError: nil,
    }

    // テストの実行
    err := sampleUsecase.Exec(mockClientStream)

    // 検証
    assert.NotEqual(t, nil, err)
}

func TestSampleHelloClientStreamValidateErr(t *testing.T) {
    // ユースケースのインスタンス化
    sampleUsecase := NewSampleHelloClientStreamUsecase()

    // パラメータの設定
    mockClientStream := &mockHelloClientStream{
        ctx: context.Background(),
        recvData: []*pb.HelloClientStreamRequestBody{{Text: ""}, {Text: "B"}, {Text: "C"}},
        recvError: nil,
        sendError: nil,
    }

    // テストの実行
    err := sampleUsecase.Exec(mockClientStream)

    // 検証
    assert.NotEqual(t, nil, err)
}

package sample

import (
    "errors"
    "fmt"
    "io"

    "go-grpc/internal/util/logger"
    pb "go-grpc/pb/sample"

    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

// インターフェースの定義
type SampleHelloBidirectionalStreamUsecase interface {
    Exec(stream grpc.BidiStreamingServer[pb.HelloBidirectionalStreamRequestBody, pb.HelloBidirectionalStreamResponseBody]) error
}

// 構造体の定義
type sampleHelloBidirectionalStreamUsecase struct{}

// インスタンス生成用関数の定義
func NewSampleHelloBidirectionalStreamUsecase() SampleHelloBidirectionalStreamUsecase {
    return &sampleHelloBidirectionalStreamUsecase{}
}

func (u *sampleHelloBidirectionalStreamUsecase) Exec(stream grpc.BidiStreamingServer[pb.HelloBidirectionalStreamRequestBody, pb.HelloBidirectionalStreamResponseBody]) error {
    // コンテキストを取得
    ctx := stream.Context()

    for {
        req, err := stream.Recv()
        if errors.Is(err, io.EOF) {
            return nil
        }
        if err != nil {
            return err
        }

        // バリデーションチェック
        if err := req.Validate(); err != nil {
            msg := fmt.Sprintf("バリデーションエラー：%s", err.Error())
            logger.Warn(ctx, msg)

            return status.Errorf(codes.InvalidArgument, "%s", err.Error())
        }

        msg := fmt.Sprintf("Hello, %s !!", req.GetText())
        if err := stream.Send(&pb.HelloBidirectionalStreamResponseBody{Message: msg}); err != nil {
            return err
        }
    }
}

package sample

import (
    "context"
    "fmt"
    "io"
    "testing"

    pb "go-grpc/pb/sample"

    "github.com/stretchr/testify/assert"
    "google.golang.org/grpc"
)

// HelloBidirectionalStreamのstream用のモック構造体
type mockHelloBidirectionalStream struct {
    grpc.BidiStreamingServer[pb.HelloBidirectionalStreamRequestBody, pb.HelloBidirectionalStreamResponseBody]
    ctx context.Context
    sent []*pb.HelloBidirectionalStreamResponseBody
    recv []*pb.HelloBidirectionalStreamRequestBody
    recvIndex int
    sendError error
    recvError error
}

func (m *mockHelloBidirectionalStream) Send(resp *pb.HelloBidirectionalStreamResponseBody) error {
    if m.sendError != nil {
        return m.sendError
    }
    m.sent = append(m.sent, resp)
    return nil
}

func (m *mockHelloBidirectionalStream) Recv() (*pb.HelloBidirectionalStreamRequestBody, error) {
    if m.recvError != nil {
        return nil, m.recvError
    }
    if m.recvIndex >= len(m.recv) {
        return nil, io.EOF
    }
    req := m.recv[m.recvIndex]
    m.recvIndex++
    return req, nil
}

func (m *mockHelloBidirectionalStream) Context() context.Context {
    return m.ctx
}

func TestSampleHelloBidirectionaStreamOK(t *testing.T) {
    // ユースケースのインスタンス化
    sampleUsecase := NewSampleHelloBidirectionalStreamUsecase()

    // パラメータの設定
    mockBidirectionalStream := &mockHelloBidirectionalStream{
        ctx: context.Background(),
        recv: []*pb.HelloBidirectionalStreamRequestBody{{Text: "Tanaka"}},
        recvError: nil,
        sendError: nil,
    }

    // テストの実行
    err := sampleUsecase.Exec(mockBidirectionalStream)

    // 検証
    assert.Equal(t, nil, err)
}

func TestSampleHelloBidirectionaStreamRecvErr(t *testing.T) {
    // ユースケースのインスタンス化
    sampleUsecase := NewSampleHelloBidirectionalStreamUsecase()

    // パラメータの設定
    mockBidirectionalStream := &mockHelloBidirectionalStream{
        ctx: context.Background(),
        recv: []*pb.HelloBidirectionalStreamRequestBody{{Text: "Tanaka"}},
        recvError: fmt.Errorf("error"),
        sendError: nil,
    }

    // テストの実行
    err := sampleUsecase.Exec(mockBidirectionalStream)

    // 検証
    assert.NotEqual(t, nil, err)
}

func TestSampleHelloBidirectionaStreamValidateErr(t *testing.T) {
    // ユースケースのインスタンス化
    sampleUsecase := NewSampleHelloBidirectionalStreamUsecase()

    // パラメータの設定
    mockBidirectionalStream := &mockHelloBidirectionalStream{
        ctx: context.Background(),
        recv: []*pb.HelloBidirectionalStreamRequestBody{{Text: ""}},
        recvError: nil,
        sendError: nil,
    }

    // テストの実行
    err := sampleUsecase.Exec(mockBidirectionalStream)

    // 検証
    assert.NotEqual(t, nil, err)
}

func TestSampleHelloBidirectionaStreamSendErr(t *testing.T) {
    // ユースケースのインスタンス化
    sampleUsecase := NewSampleHelloBidirectionalStreamUsecase()

    // パラメータの設定
    mockBidirectionalStream := &mockHelloBidirectionalStream{
        ctx: context.Background(),
        recv: []*pb.HelloBidirectionalStreamRequestBody{{Text: "Tanaka"}},
        recvError: nil,
        sendError: fmt.Errorf("error"),
    }

    // テストの実行
    err := sampleUsecase.Exec(mockBidirectionalStream)

    // 検証
    assert.NotEqual(t, nil, err)
}

package sample

import (
    "context"

    repositorySample "go-grpc/internal/repositories/sample"
    serviceSample "go-grpc/internal/services/sample"
    usecaseSample "go-grpc/internal/usecases/sample"
    pb "go-grpc/pb/sample"

    "google.golang.org/grpc"
)

type sample struct {
    pb.UnimplementedSampleServiceServer
}

func NewSample() *sample {
    return &sample{}
}

func (s *sample) Hello(ctx context.Context, in *pb.Empty) (*pb.HelloResponseBody, error) {
    // インスタンス生成
    sampleRepository := repositorySample.NewSampleRepository()
    sampleService := serviceSample.NewSampleService(sampleRepository)
    sampleUsecase := usecaseSample.NewSampleHelloUsecase(sampleService)

    // ユースケースを実行
    return sampleUsecase.Exec(ctx, in)
}

func (s *sample) HelloAddText(ctx context.Context, in *pb.HelloAddTextRequestBody) (*pb.HelloAddTextResponseBody, error) {
    // インスタンス生成
    sampleUsecase := usecaseSample.NewSampleHelloAddTextUsecase()

    // ユースケースの実行
    return sampleUsecase.Exec(ctx, in)
}

// サーバーストリーミングのメソッド
func (s *sample) HelloServerStream(in *pb.HelloServerStreamRequestBody, stream grpc.ServerStreamingServer[pb.HelloServerStreamResponseBody]) error {
    // インスタンス生成
    sampleUsecase := usecaseSample.NewSampleHelloServerStreamUsecase()

    // ユースケースの実行
    return sampleUsecase.Exec(in, stream)
}

// クライアントストリーミングのメソッド
func (s *sample) HelloClientStream(stream grpc.ClientStreamingServer[pb.HelloClientStreamRequestBody, pb.HelloClientStreamResponseBody]) error {
    // インスタンス生成
    sampleUsecase := usecaseSample.NewSampleHelloClientStreamUsecase()

    // ユースケースの実行
    return sampleUsecase.Exec(stream)
}

// 双方向ストリーミングのメソッド
func (s *sample) HelloBidirectionalStream(stream grpc.BidiStreamingServer[pb.HelloBidirectionalStreamRequestBody, pb.HelloBidirectionalStreamResponseBody]) error {
    // インスタンス生成
    sampleUsecase := usecaseSample.NewSampleHelloBidirectionalStreamUsecase()

    // ユースケースの実行
    return sampleUsecase.Exec(stream)
}

package sample

import (
    "context"

    repositorySample "go-grpc/internal/repositories/sample"
    serviceSample "go-grpc/internal/services/sample"
    usecaseSample "go-grpc/internal/usecases/sample"
    pb "go-grpc/pb/sample"
)

type sampleApi struct {
    pb.UnimplementedSampleServiceServer
}

func NewSampleApi() *sampleApi {
    return &sampleApi{}
}

// gRPC-Gateway（GETメソッド）
func (s *sampleApi) HelloApi(ctx context.Context, in *pb.Empty) (*pb.HelloResponseBody, error) {
    // インスタンス生成
    sampleRepository := repositorySample.NewSampleRepository()
    sampleService := serviceSample.NewSampleService(sampleRepository)
    sampleUsecase := usecaseSample.NewSampleHelloUsecase(sampleService)

    // ユースケースを実行
    return sampleUsecase.Exec(ctx, in)
}

// gRPC-Gateway（POSTメソッド）
func (s *sampleApi) HelloAddTextApi(ctx context.Context, in *pb.HelloAddTextRequestBody) (*pb.HelloAddTextResponseBody, error) {
    // インスタンス生成
    sampleUsecase := usecaseSample.NewSampleHelloAddTextUsecase()

    // ユースケースの実行
    return sampleUsecase.Exec(ctx, in)
}

package sample

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    "testing"

    pb "go-grpc/pb/sample"

    "github.com/stretchr/testify/assert"
)

// カバレッジの対象から除外
func TestExcludeFromCoverage(t *testing.T) {
    s := NewSampleApi()
    _, _ = s.HelloApi(context.Background(), &pb.Empty{})
    _, _ = s.HelloAddTextApi(context.Background(), &pb.HelloAddTextRequestBody{Text: "Add World !"})
}

func TestSampleHelloApi(t *testing.T) {
    // リクエストURLの設定
    gatewayPort := os.Getenv("GATEWAY_PORT")
    if gatewayPort == "" {
        gatewayPort = "8080"
    }
    path := "/api/v1/hello"
    url := fmt.Sprintf("http://localhost:%s%s", gatewayPort, path)

    // リクエストの設定
    req, _ := http.NewRequest("GET", url, nil)

    // httpクライアントの初期化
    client := new(http.Client)

    // テストの実行
    res, err := client.Do(req)
    if err != nil {
        t.Fatalf("Failed to call client.Do: %v", err)
    }
    defer res.Body.Close()

    // レスポンスボディをデコード
    var resBody pb.HelloResponseBody
    if err := json.NewDecoder(res.Body).Decode(&resBody); err != nil {
        t.Fatalf("Failed to decode response body: %v", err)
    }

    // 検証
    assert.Equal(t, 200, res.StatusCode)
    assert.Equal(t, "Testing Hello World !!", resBody.Message)
}

func TestSampleHelloAddTextApi(t *testing.T) {
    // リクエストURLの設定
    gatewayPort := os.Getenv("GATEWAY_PORT")
    if gatewayPort == "" {
        gatewayPort = "8080"
    }
    path := "/api/v1/hello"
    url := fmt.Sprintf("http://localhost:%s%s", gatewayPort, path)

    // リクエストの設定
    reqBodyJsonByte := []byte(`{"text": "Add World !"}`)
    reqBody := bytes.NewBuffer(reqBodyJsonByte)
    req, err := http.NewRequest("POST", url, reqBody)
    if err != nil {
        t.Fatalf("Failed to create request: %v", err)
    }
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer token")

    // httpクライアントの初期化
    client := new(http.Client)

    // テストの実行
    res, err := client.Do(req)
    if err != nil {
        t.Fatalf("Failed to call client.Do: %v", err)
    }
    defer res.Body.Close()

    // レスポンスボディをデコード
    var resBody pb.HelloAddTextResponseBody
    if err := json.NewDecoder(res.Body).Decode(&resBody); err != nil {
        t.Fatalf("Failed to decode response body: %v", err)
    }

    // 検証
    assert.Equal(t, 200, res.StatusCode)
    assert.Equal(t, "Hello Add World !", resBody.Message)
}

package middleware

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "strings"

    utilCtx "go-grpc/internal/util/context"
    "go-grpc/internal/util/logger"

    "github.com/google/uuid"
)

// エラーレスポンス用の構造体
type errorResponse struct {
    Message string `json:"message"`
}

// リクエスト用のミドルウェア（gRPC-Gateway用）
func RequestMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // ctxにx-request-idを設定
        requestId := uuid.New().String()
        ctx := r.Context()
        ctx = context.WithValue(ctx, utilCtx.XRequestId, requestId)

        // レスポンスヘッダーにx-request-idを設定
        w.Header().Set(string(utilCtx.XRequestId), requestId)

        // リクエストヘッダーからx-request-sourceを取得
        requestSource := r.Header.Get(string(utilCtx.XRequestSource))
        if requestSource == "" {
            requestSource = "-"
        }

        // ctxにx-request-sourceを設定
        ctx = context.WithValue(ctx, utilCtx.XRequestSource, requestSource)

        // リクエスト開始のログ出力
        logger.Info(ctx, "start gRPC-Gateway request")

        // コンテキストを更新
        r = r.WithContext(ctx)

        // 処理を実行
        next.ServeHTTP(w, r)

        // リクエスト終了のログ出力
        logger.Info(ctx, "finish gRPC-Gateway request")
    })
}

// 認証用ミドルウェア（gRPC-Gateway用）
func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 対象外のメソッドとエンドポイントを設定
        skipMethodAndEndpoints := []map[string]string{
            {
                "method": http.MethodGet,
                "endpoint": "/api/v1/hello",
            },
        }

        // 特定のメソッドかつエンドポイントの場合にスキップ
        for _, target := range skipMethodAndEndpoints {
            if r.Method == target["method"] && r.URL.Path == target["endpoint"] {
                next.ServeHTTP(w, r)
                return
            }
        }

        ctx := r.Context()

        // リクエストヘッダーからAuthorizationを取得
        authorization := r.Header.Get("Authorization")
        if authorization == "" {
            // レスポンスをJSON形式で構築
            w.Header().Set("Content-Type", "application/json")
            w.WriteHeader(http.StatusUnauthorized)

            // エラーメッセージをJSONでエンコード
            errRes := errorResponse{Message: "認証用トークンが設定されていません。"}
            if err := json.NewEncoder(w).Encode(errRes); err != nil {
                // ctxにstatusとstatusCodeを設定
                ctx = context.WithValue(ctx, utilCtx.Status, "Internal Server Error")
                ctx = context.WithValue(ctx, utilCtx.StatusCode, "500")

                logger.Error(ctx, fmt.Sprintf("Internal Server Error: %v", err))
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }

            // ctxにstatusとstatusCodeを設定
            ctx = context.WithValue(ctx, utilCtx.Status, "Unauthorized")
            ctx = context.WithValue(ctx, utilCtx.StatusCode, "401")

            logger.Warn(ctx, "認証用トークンが設定されていません。")

            return
        }

        // トークンを取得
        token := strings.TrimPrefix(authorization, "Bearer ")
        if token == "" {
            // レスポンスをJSON形式で構築
            w.Header().Set("Content-Type", "application/json")
            w.WriteHeader(http.StatusUnauthorized)

            // エラーメッセージをJSONでエンコード
            errRes := errorResponse{Message: "認証用トークンが設定されていません。"}
            if err := json.NewEncoder(w).Encode(errRes); err != nil {
                // ctxにstatusとstatusCodeを設定
                ctx = context.WithValue(ctx, utilCtx.Status, "Internal Server Error")
                ctx = context.WithValue(ctx, utilCtx.StatusCode, "500")

                logger.Error(ctx, fmt.Sprintf("Internal Server Error: %v", err))
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }

            // ctxにstatusとstatusCodeを設定
            ctx = context.WithValue(ctx, utilCtx.Status, "Unauthorized")
            ctx = context.WithValue(ctx, utilCtx.StatusCode, "401")

            logger.Warn(ctx, "認証用トークンが設定されていません。")

            return
        }

        // TODO: 認証チェック処理を追加

        // 処理を実行
        next.ServeHTTP(w, r)
    })
}

package main

import (
    "context"
    "fmt"
    "log/slog"
    "net"
    "net/http"
    "os"

    "go-grpc/internal/interceptor"
    mw "go-grpc/internal/middleware"
    sGrpcSample "go-grpc/internal/servers/grpc/sample"
    sGwSample "go-grpc/internal/servers/gw/sample"
    pbSample "go-grpc/pb/sample"

    "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
    "github.com/joho/godotenv"
    "github.com/rs/cors"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    "google.golang.org/grpc/reflection"
)

// gRPC-Gatewayのサーバー起動用の関数
func grpcGateway(grpcPort, gatewayPort string) error {
    // gRPC-Serverへのエンドポイント設定
    ctx := context.Background()
    mux := runtime.NewServeMux()
    grpcServer := fmt.Sprintf("localhost:%s", grpcPort)
    opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
    if err := pbSample.RegisterSampleServiceHandlerFromEndpoint(ctx, mux, grpcServer, opts); err != nil {
        return err
    }

    // gRPC-Gatewayのエンドポイント設定
    if err := pbSample.RegisterSampleServiceHandlerServer(ctx, mux, sGwSample.NewSampleApi()); err != nil {
        return err
    }

    // CORSの設定
    corsHandler := cors.New(cors.Options{
        AllowedOrigins: []string{"http://localhost:3000"},
        AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
        AllowedHeaders: []string{"Authorization", "Content-Type"},
        AllowCredentials: true,
        MaxAge: 300,
    })

    // ミドルウェアの設定（muxをラップ）
    handler := mw.RequestMiddleware(mw.AuthMiddleware(corsHandler.Handler(mux)))

    // HTTPサーバーの起動
    listener := fmt.Sprintf(":%s", gatewayPort)
    return http.ListenAndServe(listener, handler)
}

func main() {
    // .env ファイルの読み込み
    err := godotenv.Load()
    if err != nil {
        slog.Error(fmt.Sprintf(".envファイルの読み込みに失敗しました。: %v", err))
    }

    // ENVの設定
    env := os.Getenv("ENV")
    if env == "" {
        env = "local"
    }

    // gRPC用のポート番号の設定
    grpcPort := os.Getenv("GRPC_PORT")
    if grpcPort == "" {
        grpcPort = "50051"
    }

    // gRPC-Gateway用のポート番号の設定
    gatewayPort := os.Getenv("GATEWAY_PORT")
    if gatewayPort == "" {
        gatewayPort = "8080"
    }

    // Listenerの設定
    listener, err := net.Listen("tcp", fmt.Sprintf(":%s", grpcPort))
    if err != nil {
        slog.Error(fmt.Sprintf("Listenerの設定に失敗しました。: %v", err))
    }

    // gRPCサーバーの作成
    s := grpc.NewServer(
        // インターセプターの適用
        grpc.ChainUnaryInterceptor(
            interceptor.RequestUnaryInterceptor,
            interceptor.AuthUnaryInterceptor,
        ),
        grpc.ChainStreamInterceptor(
            interceptor.RequestStreamInterceptor,
            interceptor.AuthStreamInterceptor,
        ),
    )

    // サービス設定
    pbSample.RegisterSampleServiceServer(s, sGrpcSample.NewSample())

    // リフレクション設定
    reflection.Register(s)

    // gRPCサーバーの起動（非同期）
    slog.Info(fmt.Sprintf("[ENV=%s] start gRPC-Server port: %s", env, grpcPort))
    go func() {
        if err := s.Serve(listener); err != nil {
            slog.Error(fmt.Sprintf("gRPC-Server の起動に失敗しました。: %v", err))
        }
    }()

    // gRPC-Gatewayの起動
    slog.Info(fmt.Sprintf("[ENV=%s] start gRPC-Gateway port: %s", env, gatewayPort))
    if err := grpcGateway(grpcPort, gatewayPort); err != nil {
        slog.Error(fmt.Sprintf("gRPC-Gatewayの起動に失敗しました。: %v", err))
    }
}

ENV=production
GRPC_PORT=50051
GATEWAY_PORT=8080