Golang实现用户认证与数据存储的最佳实践

在Go中实现用户认证和数据存储，可以采用以下方案：

用户认证

推荐使用JWT（JSON Web Tokens）结合gRPC拦截器实现认证。以下是一个基础示例：

package main

import (
	"context"
	"fmt"
	"strings"

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

	"github.com/golang-jwt/jwt/v4"
)

type AuthInterceptor struct {
	jwtSecret []byte
}

func (ai *AuthInterceptor) UnaryInterceptor() grpc.UnaryServerInterceptor {
	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
		// 跳过观看调用的认证
		if strings.Contains(info.FullMethod, "Watch") {
			return handler(ctx, req)
		}

		// 从元数据获取令牌
		md, ok := metadata.FromIncomingContext(ctx)
		if !ok {
			return nil, status.Error(codes.Unauthenticated, "missing metadata")
		}

		authHeaders := md["authorization"]
		if len(authHeaders) == 0 {
			return nil, status.Error(codes.Unauthenticated, "missing authorization header")
		}

		tokenString := strings.TrimPrefix(authHeaders[0], "Bearer ")
		token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
			if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
				return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
			}
			return ai.jwtSecret, nil
		})

		if err != nil || !token.Valid {
			return nil, status.Error(codes.Unauthenticated, "invalid token")
		}

		return handler(ctx, req)
	}
}

// 登录处理示例
func Login(username, password string) (string, error) {
	// 验证用户凭据（这里简化处理）
	if username != "testuser" || password != "testpass" {
		return "", status.Error(codes.Unauthenticated, "invalid credentials")
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"username": username,
		"exp":      jwt.TimeFunc().Add(24 * time.Hour).Unix(),
	})

	return token.SignedString([]byte("your-secret-key"))
}

数据存储

对于50MB以下的文件存储，建议使用本地文件系统或云存储服务。以下是本地存储的示例：

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io"
	"os"
	"path/filepath"
)

type FileStorage struct {
	basePath string
}

func NewFileStorage(basePath string) *FileStorage {
	return &FileStorage{basePath: basePath}
}

func (fs *FileStorage) SaveFile(userID string, fileData []byte, filename string) (string, error) {
	// 创建用户目录
	userDir := filepath.Join(fs.basePath, userID)
	if err := os.MkdirAll(userDir, 0755); err != nil {
		return "", fmt.Errorf("failed to create user directory: %v", err)
	}

	// 生成文件哈希作为唯一标识
	hash := sha256.Sum256(fileData)
	fileHash := hex.EncodeToString(hash[:])
	
	// 保存文件
	filePath := filepath.Join(userDir, fileHash+"_"+filename)
	if err := os.WriteFile(filePath, fileData, 0644); err != nil {
		return "", fmt.Errorf("failed to save file: %v", err)
	}

	return fileHash, nil
}

func (fs *FileStorage) GetFile(userID, fileHash string) ([]byte, error) {
	userDir := filepath.Join(fs.basePath, userID)
	
	// 查找匹配的文件
	files, err := filepath.Glob(filepath.Join(userDir, fileHash+"_*"))
	if err != nil {
		return nil, fmt.Errorf("failed to search files: %v", err)
	}
	
	if len(files) == 0 {
		return nil, fmt.Errorf("file not found")
	}

	return os.ReadFile(files[0])
}

// 使用示例
func main() {
	storage := NewFileStorage("./user_files")
	
	// 保存文件
	fileID, err := storage.SaveFile("user123", []byte("file content"), "document.txt")
	if err != nil {
		fmt.Printf("Error saving file: %v\n", err)
		return
	}
	
	fmt.Printf("File saved with ID: %s\n", fileID)
	
	// 读取文件
	data, err := storage.GetFile("user123", fileID)
	if err != nil {
		fmt.Printf("Error reading file: %v\n", err)
		return
	}
	
	fmt.Printf("File content: %s\n", string(data))
}

gRPC服务集成

在gRPC服务中集成认证和存储：

package main

import (
	"context"

	"google.golang.org/grpc"
)

type WorldSimulationServer struct {
	storage *FileStorage
}

func (s *WorldSimulationServer) SaveUserFile(ctx context.Context, req *SaveFileRequest) (*SaveFileResponse, error) {
	// 认证已在拦截器中处理
	fileID, err := s.storage.SaveFile(req.UserId, req.FileData, req.Filename)
	if err != nil {
		return nil, status.Error(codes.Internal, err.Error())
	}

	return &SaveFileResponse{FileId: fileID}, nil
}

func main() {
	storage := NewFileStorage("./user_files")
	interceptor := &AuthInterceptor{jwtSecret: []byte("your-secret-key")}
	
	server := grpc.NewServer(
		grpc.UnaryInterceptor(interceptor.UnaryInterceptor()),
	)
	
	simServer := &WorldSimulationServer{storage: storage}
	RegisterWorldSimulationServer(server, simServer)
	
	// 启动服务器...
}

这个方案提供了完整的认证流程和文件存储功能，避免了外部服务的依赖，可以直接集成到现有的gRPC应用中。JWT认证通过gRPC拦截器自动处理，文件存储使用本地文件系统，支持多用户和多文件存储。