マイクロサービスアーキテクチャでのフィーチャーフラグの活用方法

my-feature-service/
├── cmd/
│   └── greeter-server/
│       └── main.go                # サーバー起動のエントリーポイント
├── internal/
│   ├── config/
│   │   └── config.go              # 設定（フィーチャーフラグ含む）の読み込み
│   ├── feature/
│   │   └── flags.go               # フィーチャーフラグの判定ロジック
│   ├── handler/
│   │   └── greeter_handler.go     # gRPCリクエストハンドラ
│   └── service/
│       └── greeter_service.go     # ビジネスロジック（今回はハンドラに統合も可）
├── pkg/                           # 他のサービスと共有する可能性のあるコード (今回は未使用)
├── proto/
│   └── greeter/
│       └── greeter.proto          # Protobuf定義ファイル
│       └── greeter.pb.go          # 生成されたGoコード
│       └── greeter_grpc.pb.go     # 生成されたGoコード (gRPC)
├── go.mod
├── go.sum
├── config.yaml                    # フィーチャーフラグの設定ファイル
└── kubernetes/
    ├── configmap.yaml             # Kubernetes ConfigMap定義
    └── deployment.yaml            # Kubernetes Deployment定義

syntax = "proto3";

package greeter;

option go_package = "my-feature-service/proto/greeter";

// The greeter service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

mkdir -p proto/greeter
protoc --go_out=. --go_opt=paths=source_relative \
    --go-grpc_out=. --go-grpc_opt=paths=source_relative \
    proto/greeter/greeter.proto

features:
  newWelcomeMessage: true
  experimentalGreeting: false
  userSpecificFeature:
    enabled: true
    users: ["alice", "bob"]

package config

import (
	"os"
	"log"
	"gopkg.in/yaml.v3"
)

type FeatureFlags struct {
	NewWelcomeMessage    bool                   `yaml:"newWelcomeMessage"`
	ExperimentalGreeting bool                   `yaml:"experimentalGreeting"`
	UserSpecificFeature  UserSpecificFeatureCfg `yaml:"userSpecificFeature"`
}

type UserSpecificFeatureCfg struct {
	Enabled bool     `yaml:"enabled"`
	Users   []string `yaml:"users"`
}

type Config struct {
	Features FeatureFlags `yaml:"features"`
}

var globalConfig *Config

func LoadConfig(configPath string) (*Config, error) {
	data, err := os.ReadFile(configPath)
	if err != nil {
		return nil, err
	}

	var cfg Config
	err = yaml.Unmarshal(data, &cfg)
	if err != nil {
		return nil, err
	}
	globalConfig = &cfg
	log.Println("Configuration loaded successfully.")
	log.Printf("Feature - NewWelcomeMessage: %v\n", cfg.Features.NewWelcomeMessage)
	log.Printf("Feature - ExperimentalGreeting: %v\n", cfg.Features.ExperimentalGreeting)
	log.Printf("Feature - UserSpecificFeature Enabled: %v for users: %v\n", cfg.Features.UserSpecificFeature.Enabled, cfg.Features.UserSpecificFeature.Users)
	return &cfg, nil
}

func GetConfig() *Config {
	if globalConfig == nil {
		// 本番環境ではエラー処理やデフォルト値の設定をより堅牢にすべきだ。
		// ここでは簡略化のため、LoadConfigが事前に呼ばれることを期待する。
		log.Fatal("Configuration not loaded. Call LoadConfig first.")
	}
	return globalConfig
}

package feature

import (
	"my-feature-service/internal/config"
	"slices" // Go 1.21+
)

// IsNewWelcomeMessageEnabled は新しい歓迎メッセージ機能が有効かどうかを返す。
func IsNewWelcomeMessageEnabled() bool {
	cfg := config.GetConfig()
	return cfg.Features.NewWelcomeMessage
}

// IsExperimentalGreetingEnabled は実験的な挨拶機能が有効かどうかを返す。
func IsExperimentalGreetingEnabled() bool {
	cfg := config.GetConfig()
	return cfg.Features.ExperimentalGreeting
}

// IsUserSpecificFeatureEnabledFor は特定のユーザーに対して機能が有効かどうかを返す。
func IsUserSpecificFeatureEnabledFor(userName string) bool {
	cfg := config.GetConfig()
	if !cfg.Features.UserSpecificFeature.Enabled {
		return false
	}
	// Go 1.21以降で利用可能な slices.Contains を使用。
	// それ以前のバージョンではループで確認する。
	return slices.Contains(cfg.Features.UserSpecificFeature.Users, userName)
}

package handler

import (
	"context"
	"fmt"
	pb "my-feature-service/proto/greeter"
	"my-feature-service/internal/feature"
	"log"
)

// Server は greeter.GreeterServer を実装する。
type GreeterServer struct {
	pb.UnimplementedGreeterServer // 将来のバージョンのための前方互換性
}

func NewGreeterServer() *GreeterServer {
	return &GreeterServer{}
}

func (s *GreeterServer) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
	log.Printf("Received SayHello request for name: %s", req.GetName())
	userName := req.GetName()
	message := ""

	if feature.IsNewWelcomeMessageEnabled() {
		message = fmt.Sprintf("✨ Welcome, %s! This is the new greeting! ✨", userName)
	} else {
		message = fmt.Sprintf("Hello, %s.", userName)
	}

	if feature.IsExperimentalGreetingEnabled() {
		message += " (You are seeing an experimental feature!)"
	}

	if feature.IsUserSpecificFeatureEnabledFor(userName) {
		message += fmt.Sprintf(" [SPECIAL FEATURE FOR %s ACTIVATED!]", userName)
	}

	log.Printf("Sending reply: %s", message)
	return &pb.HelloReply{Message: message}, nil
}

package main

import (
	"log"
	"net"
	"os"

	"google.golang.org/grpc"
	"my-feature-service/internal/config"
	"my-feature-service/internal/handler"
	pb "my-feature-service/proto/greeter"
)

const (
	defaultPort       = "50051"
	defaultConfigPath = "./config.yaml" // ローカル実行時のデフォルトパス
)

func main() {
	port := os.Getenv("PORT")
	if port == "" {
		port = defaultPort
	}

	configPath := os.Getenv("CONFIG_PATH")
	if configPath == "" {
		configPath = defaultConfigPath
	}

	// 設定ファイルの読み込み
	_, err := config.LoadConfig(configPath)
	if err != nil {
		log.Fatalf("Failed to load configuration: %v", err)
	}

	lis, err := net.Listen("tcp", ":"+port)
	if err != nil {
		log.Fatalf("Failed to listen: %v", err)
	}

	s := grpc.NewServer()
	greeterServer := handler.NewGreeterServer()
	pb.RegisterGreeterServer(s, greeterServer)

	log.Printf("Server listening at %v", lis.Addr())
	if err := s.Serve(lis); err != nil {
		log.Fatalf("Failed to serve: %v", err)
	}
}

apiVersion: v1
kind: ConfigMap
metadata:
  name: greeter-config
  namespace: default # 環境に合わせて変更
data:
  config.yaml: |
    features:
      newWelcomeMessage: true
      experimentalGreeting: false
      userSpecificFeature:
        enabled: true
        users: ["alice", "bob", "charlie-from-k8s"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: greeter-service
  namespace: default # 環境に合わせて変更
  labels:
    app: greeter
spec:
  replicas: 1
  selector:
    matchLabels:
      app: greeter
  template:
    metadata:
      labels:
        app: greeter
    spec:
      containers:
      - name: greeter-server
        image: your-repo/my-feature-service:latest # 作成したDockerイメージを指定
        ports:
        - containerPort: 50051
        env:
        - name: PORT
          value: "50051"
        - name: CONFIG_PATH # コンテナ内の設定ファイルパス
          value: "/app/config/config.yaml"
        volumeMounts:
        - name: config-volume
          mountPath: /app/config # マウント先のディレクトリ
          readOnly: true
      volumes:
      - name: config-volume
        configMap:
          name: greeter-config # 作成したConfigMapの名前
          items:
          - key: config.yaml
            path: config.yaml # マウントするファイル名

# ビルドステージ
FROM golang:1.22-alpine AS builder

WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download

COPY . .

# protoファイルからGoコードを生成 (必要に応じて)
# RUN apt-get update && apt-get install -y protobuf-compiler
# RUN go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
# RUN go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
# RUN protoc --go_out=. --go_opt=paths=source_relative \
#     --go-grpc_out=. --go-grpc_opt=paths=source_relative \
#     proto/greeter/greeter.proto

RUN CGO_ENABLED=0 GOOS=linux go build -o /app/greeter-server ./cmd/greeter-server

# 実行ステージ
FROM alpine:latest

RUN apk --no-cache add ca-certificates

WORKDIR /app

# ビルドステージから実行ファイルと設定ファイルをコピー
COPY --from=builder /app/greeter-server /app/greeter-server
# COPY config.yaml /app/config.yaml # ConfigMapを使う場合は不要

# ポート開放
EXPOSE 50051

# 環境変数 (ConfigMapで上書きされるパスのデフォルト)
# ENV CONFIG_PATH=/app/config.yaml

# 実行コマンド
CMD ["/app/greeter-server"]