Go语言银行系统架构实践：从设计到部署的全栈技术指南

2026-04-15 08:20:54作者：齐添朝

SimpleBank项目是一个基于Go语言构建的现代化银行后端服务，它不仅实现了完整的银行核心业务功能，更展示了如何运用Go生态系统的最佳实践构建高可用、安全且可扩展的金融服务。本文将深入剖析该项目的技术架构、核心功能实现以及生产环境部署策略，为中高级开发者提供一个全面的学习案例。通过研究SimpleBank，您将掌握Go语言在金融领域的应用模式，了解分布式系统设计原则，以及如何将理论知识转化为可落地的生产级代码。

项目价值：Go语言在金融系统中的技术优势

SimpleBank项目作为Go语言后端开发的典范，展示了Go在构建金融系统时的独特优势。与传统金融系统常用的Java或C#相比，Go语言提供了更简洁的语法、更高效的内存管理和更强大的并发处理能力，特别适合构建高性能、低延迟的银行服务。

金融级系统的技术挑战与解决方案

银行系统面临的核心技术挑战包括数据一致性、事务安全性、高并发处理和系统可用性。SimpleBank通过精心设计的架构和技术选型，为这些挑战提供了切实可行的解决方案：

数据一致性：采用PostgreSQL的ACID事务特性，结合乐观锁和悲观锁机制确保资金操作的准确性
安全防护：实现基于JWT/PASETO的双重认证机制，配合BCrypt密码哈希和HTTPS加密传输
并发处理：利用Go的goroutine和channel特性，实现高效的并发请求处理
高可用设计：通过Docker容器化和Kubernetes编排，实现服务的弹性伸缩和故障转移

与同类项目的差异化优势

SimpleBank相比其他开源银行项目具有以下显著优势：

特性	SimpleBank	传统Java银行系统	其他Go语言项目
性能	高（goroutine轻量级并发）	中（线程模型开销大）	高
内存占用	低（Go语言高效内存管理）	高（JVM内存模型）	中
开发效率	高（简洁语法，强类型）	中（冗长代码，企业级框架）	高
部署复杂度	低（单一二进制文件）	高（依赖JVM和应用服务器）	中
学习曲线	中等（Go语言+金融业务）	陡峭（复杂框架+金融业务）	平缓（仅Go语言）

项目架构概览

SimpleBank采用清晰的分层架构，将业务逻辑、数据访问和API层严格分离，同时支持RESTful HTTP和gRPC两种接口协议。这种设计不仅提高了代码的可维护性，也为未来的微服务拆分奠定了基础。

图1：Backend Master Class课程封面图，展示了SimpleBank项目涉及的核心技术栈和开发流程

核心功能：银行系统的业务实现

SimpleBank实现了现代银行系统的核心功能集，从用户管理到资金转账，每个功能都经过精心设计，确保安全性、可靠性和性能。

用户认证与授权系统

用户认证是银行系统的第一道安全防线。SimpleBank实现了完整的用户生命周期管理，包括注册、登录、密码重置和权限控制。

多令牌认证机制

项目同时支持JWT（JSON Web Token）和PASETO（Platform-Agnostic Security Tokens）两种令牌机制，提供了灵活的安全选择：

// token/maker.go - 令牌生成接口定义
type Maker interface {
    // 创建新令牌
    CreateToken(username string, duration time.Duration) (string, *Payload, error)
    // 验证令牌
    VerifyToken(token string) (*Payload, error)
}

JWT和PASETO各有优势：JWT生态成熟、应用广泛；PASETO设计更安全，避免了JWT的一些已知漏洞。开发者可以根据安全需求选择合适的令牌方案。

基于角色的访问控制(RBAC)

系统实现了细粒度的权限控制，定义了不同用户角色及其权限范围：

// util/role.go - 角色定义
const (
    RoleAdmin     = "admin"
    RoleDepositor = "depositor"
    RoleTeller    = "teller"
)

权限验证中间件确保只有授权用户才能访问特定API：

// api/middleware.go - 角色验证中间件
func roleMiddleware(roles ...string) gin.HandlerFunc {
    return func(ctx *gin.Context) {
        // 从上下文获取用户信息
        payloadValue, exists := ctx.Get(authorizationPayloadKey)
        if !exists {
            // 未认证处理
            return
        }
        
        // 检查用户角色是否在允许列表中
        payload := payloadValue.(*token.Payload)
        hasRole := false
        for _, role := range roles {
            if payload.Role == role {
                hasRole = true
                break
            }
        }
        
        if !hasRole {
            // 权限不足处理
            ctx.AbortWithStatusJSON(http.StatusForbidden, errorResponse(errors.New("permission denied")))
            return
        }
        
        ctx.Next()
    }
}

账户与交易管理

账户管理是银行系统的核心功能，涉及账户创建、余额查询、交易记录等操作。

账户数据模型

账户表设计考虑了数据一致性和查询性能：

-- db/migration/000001_init_schema.up.sql
CREATE TABLE "accounts" (
  "id" bigserial PRIMARY KEY,
  "owner" varchar NOT NULL REFERENCES "users" ("username"),
  "balance" bigint NOT NULL,
  "currency" varchar NOT NULL,
  "created_at" timestamptz NOT NULL DEFAULT (now()),
  CONSTRAINT "owner_currency_key" UNIQUE ("owner", "currency")
);

通过owner_currency_key唯一约束确保用户不会为同一币种创建多个账户。

事务处理机制

资金转账是银行系统中最关键的操作，需要严格保证数据一致性：

// db/sqlc/tx_transfer.go - 转账事务实现
func (store *SQLStore) TransferTx(ctx context.Context, arg TransferTxParams) (TransferTxResult, error) {
    var result TransferTxResult

    err := store.execTx(ctx, func(q *Queries) error {
        var err error
        
        // 创建转账记录
        result.Transfer, err = q.CreateTransfer(ctx, CreateTransferParams{
            FromAccountID: arg.FromAccountID,
            ToAccountID:   arg.ToAccountID,
            Amount:        arg.Amount,
        })
        if err != nil {
            return err
        }
        
        // 从转出账户扣除金额
        result.FromEntry, err = q.CreateEntry(ctx, CreateEntryParams{
            AccountID: arg.FromAccountID,
            Amount:    -arg.Amount,
        })
        if err != nil {
            return err
        }
        
        // 向转入账户添加金额
        result.ToEntry, err = q.CreateEntry(ctx, CreateEntryParams{
            AccountID: arg.ToAccountID,
            Amount:    arg.Amount,
        })
        if err != nil {
            return err
        }
        
        // 更新账户余额（使用FOR UPDATE锁定行）
        if arg.FromAccountID < arg.ToAccountID {
            result.FromAccount, err = q.AddAccountBalance(ctx, AddAccountBalanceParams{
                ID:     arg.FromAccountID,
                Amount: -arg.Amount,
            })
            if err != nil {
                return err
            }
            
            result.ToAccount, err = q.AddAccountBalance(ctx, AddAccountBalanceParams{
                ID:     arg.ToAccountID,
                Amount: arg.Amount,
            })
            if err != nil {
                return err
            }
        } else {
            // 调整更新顺序防止死锁
            result.ToAccount, err = q.AddAccountBalance(ctx, AddAccountBalanceParams{
                ID:     arg.ToAccountID,
                Amount: arg.Amount,
            })
            if err != nil {
                return err
            }
            
            result.FromAccount, err = q.AddAccountBalance(ctx, AddAccountBalanceParams{
                ID:     arg.FromAccountID,
                Amount: -arg.Amount,
            })
            if err != nil {
                return err
            }
        }
        
        return nil
    })

    return result, err
}

这段代码展示了如何使用数据库事务确保转账操作的原子性，同时通过调整更新顺序防止死锁。

异步任务处理系统

银行系统中有许多非实时任务（如邮件发送、报表生成），SimpleBank采用基于Redis的异步任务队列处理这些操作，提高系统响应速度和吞吐量。

任务分发与处理架构

// worker/distributor.go - 任务分发器
type Distributor interface {
    DistributeTaskSendVerifyEmail(ctx context.Context, payload *payload.SendVerifyEmailTaskPayload, opts ...asynq.Option) error
}

type RedisDistributor struct {
    client *asynq.Client
}

func NewRedisDistributor(redisOpt asynq.RedisClientOpt) Distributor {
    return &RedisDistributor{
        client: asynq.NewClient(redisOpt),
    }
}

// 分发邮件验证任务
func (dist *RedisDistributor) DistributeTaskSendVerifyEmail(
    ctx context.Context,
    payload *payload.SendVerifyEmailTaskPayload,
    opts ...asynq.Option,
) error {
    jsonPayload, err := json.Marshal(payload)
    if err != nil {
        return err
    }

    task := asynq.NewTask(string(payload.TaskSendVerifyEmail), jsonPayload, opts...)
    _, err = dist.client.EnqueueContext(ctx, task)
    return err
}

任务处理器实现

// worker/processor.go - 任务处理器
type Processor interface {
    ProcessTaskSendVerifyEmail(ctx context.Context, task *asynq.Task) error
}

type RedisProcessor struct {
    server *asynq.Server
    store  db.Store
    mailer mail.Sender
}

// 处理邮件验证任务
func (processor *RedisProcessor) ProcessTaskSendVerifyEmail(ctx context.Context, task *asynq.Task) error {
    var payload payload.SendVerifyEmailTaskPayload
    if err := json.Unmarshal(task.Payload(), &payload); err != nil {
        return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
    }

    user, err := processor.store.GetUser(ctx, payload.Username)
    if err != nil {
        if errors.Is(err, db.ErrRecordNotFound) {
            return fmt.Errorf("user %s not found: %w", payload.Username, asynq.SkipRetry)
        }
        return fmt.Errorf("failed to get user: %v", err)
    }

    verifyEmail, err := processor.store.CreateVerifyEmail(ctx, db.CreateVerifyEmailParams{
        Username:   payload.Username,
        Email:      user.Email,
        SecretCode: payload.SecretCode,
    })
    if err != nil {
        return fmt.Errorf("failed to create verify email: %v", err)
    }

    subject := "Verify your email"
    content := fmt.Sprintf(`Hello %s,
Please verify your email by clicking the following link:
%s/verify-email?email=%s&code=%s
`, user.FullName, processor.config.FrontendURL, user.Email, verifyEmail.SecretCode)
    to := []string{user.Email}

    err = processor.mailer.SendEmail(subject, content, to, nil, nil, nil)
    if err != nil {
        return fmt.Errorf("failed to send email: %v", err)
    }

    return nil
}

技术解析：Go语言银行系统的架构深度剖析

SimpleBank项目采用了多项现代后端技术和架构模式，构建了一个健壮、可扩展的银行系统。本节将深入解析这些技术实现细节。

双协议API设计：REST与gRPC的融合

SimpleBank同时支持RESTful HTTP API和gRPC两种接口协议，满足不同客户端的需求。

REST API实现

使用Gin框架构建RESTful API，提供直观的HTTP接口：

// api/server.go - REST API服务器初始化
func NewServer(config util.Config, store db.Store) (*Server, error) {
    tokenMaker, err := token.NewPasetoMaker(config.TokenSymmetricKey)
    if err != nil {
        return nil, fmt.Errorf("cannot create token maker: %w", err)
    }

    server := &Server{
        config:     config,
        store:      store,
        tokenMaker: tokenMaker,
        router:     gin.Default(),
    }

    // 注册中间件
    server.setupMiddleware()
    
    // 注册路由
    server.setupRoutes()

    return server, nil
}

// api/server.go - 路由设置
func (server *Server) setupRoutes() {
    // 公开路由
    publicRoutes := server.router.Group("/")
    publicRoutes.POST("/users", server.createUser)
    publicRoutes.POST("/users/login", server.loginUser)
    publicRoutes.POST("/tokens/renew_access", server.renewAccessToken)
    
    // 需要认证的路由
    authRoutes := server.router.Group("/")
    authRoutes.Use(authMiddleware(server.tokenMaker))
    authRoutes.POST("/accounts", server.createAccount)
    authRoutes.GET("/accounts/:id", server.getAccount)
    authRoutes.GET("/accounts", server.listAccounts)
    authRoutes.POST("/transfers", server.createTransfer)
}

gRPC服务实现

使用Protocol Buffers定义服务接口，并生成高效的gRPC服务代码：

// proto/service_simple_bank.proto
syntax = "proto3";

package simple_bank;

import "google/api/annotations.proto";
import "rpc_create_user.proto";
import "rpc_login_user.proto";

service SimpleBank {
  rpc CreateUser (CreateUserRequest) returns (CreateUserResponse) {
    option (google.api.http) = {
      post: "/v1/users"
      body: "*"
    };
  }

  rpc LoginUser (LoginUserRequest) returns (LoginUserResponse) {
    option (google.api.http) = {
      post: "/v1/users/login"
      body: "*"
    };
  }
}

gRPC处理逻辑实现：

// gapi/rpc_create_user.go - gRPC CreateUser实现
func (server *Server) CreateUser(ctx context.Context, req *pb.CreateUserRequest) (*pb.CreateUserResponse, error) {
    // 验证请求
    if err := validateCreateUserRequest(req); err != nil {
        return nil, status.Errorf(codes.InvalidArgument, "invalid request: %v", err)
    }

    // 密码哈希
    hashedPassword, err := util.HashPassword(req.GetPassword())
    if err != nil {
        return nil, status.Errorf(codes.Internal, "failed to hash password: %v", err)
    }

    // 准备数据库参数
    arg := db.CreateUserParams{
        Username:       req.GetUsername(),
        HashedPassword: hashedPassword,
        FullName:       req.GetFullName(),
        Email:          req.GetEmail(),
    }

    // 调用数据库层
    user, err := server.store.CreateUser(ctx, arg)
    if err != nil {
        if pqErr, ok := err.(*pq.Error); ok {
            switch pqErr.Code.Name() {
            case "unique_violation":
                return nil, status.Errorf(codes.AlreadyExists, "username already exists: %v", err)
            }
        }
        return nil, status.Errorf(codes.Internal, "failed to create user: %v", err)
    }

    // 生成验证邮件任务
    taskPayload := &payload.SendVerifyEmailTaskPayload{
        Username:   user.Username,
        SecretCode: util.RandomString(32),
    }
    opts := []asynq.Option{
        asynq.MaxRetry(10),
        asynq.ProcessIn(10 * time.Second),
        asynq.Queue(string(worker.QueueCritical)),
    }
    err = server.taskDistributor.DistributeTaskSendVerifyEmail(ctx, taskPayload, opts...)
    if err != nil {
        log.Printf("failed to distribute task: %v", err)
        // 不返回错误，因为用户创建已经成功，邮件可以稍后重试
    }

    // 构建响应
    resp := &pb.CreateUserResponse{
        User: convertUser(user),
    }
    return resp, nil
}

数据库设计与SQLC代码生成

SimpleBank采用SQL-first的开发方式，使用SQLC工具从SQL查询生成类型安全的Go代码，避免手写ORM代码的繁琐和潜在错误。

SQLC配置

# sqlc.yaml
version: "2"
sql:
- schema: "db/migration"
  queries: "db/query"
  engine: "postgresql"
  gen:
    go: 
      package: "db"
      out: "db/sqlc"
      sql_package: "pgx/v5"
      emit_json_tags: true
      emit_interface: true
      emit_empty_slices: true
      overrides:
        - db_type: "timestamptz"
          go_type: "time.Time"
        - db_type: "uuid"
          go_type: "github.com/google/uuid.UUID"

数据库事务抽象

// db/sqlc/exec_tx.go - 事务执行器
type SQLStore struct {
    db *pgxpool.Pool
    *Queries
}

// 执行事务
func (store *SQLStore) execTx(ctx context.Context, fn func(*Queries) error) error {
    tx, err := store.db.Begin(ctx)
    if err != nil {
        return err
    }

    q := New(tx)
    err = fn(q)
    if err != nil {
        if rbErr := tx.Rollback(ctx); rbErr != nil {
            return fmt.Errorf("tx err: %v, rb err: %v", err, rbErr)
        }
        return err
    }

    return tx.Commit(ctx)
}

这种事务抽象使得业务逻辑可以专注于业务规则，而不必处理事务管理的细节。

配置管理与环境隔离

项目使用Viper管理配置，支持不同环境的配置隔离：

// util/config.go - 配置加载
type Config struct {
    Environment          string        `mapstructure:"ENVIRONMENT"`
    DBSource             string        `mapstructure:"DB_SOURCE"`
    HTTPServerAddress    string        `mapstructure:"HTTP_SERVER_ADDRESS"`
    GRPCServerAddress    string        `mapstructure:"GRPC_SERVER_ADDRESS"`
    TokenSymmetricKey    string        `mapstructure:"TOKEN_SYMMETRIC_KEY"`
    AccessTokenDuration  time.Duration `mapstructure:"ACCESS_TOKEN_DURATION"`
    RefreshTokenDuration time.Duration `mapstructure:"REFRESH_TOKEN_DURATION"`
    RedisAddress         string        `mapstructure:"REDIS_ADDRESS"`
    EmailSenderName      string        `mapstructure:"EMAIL_SENDER_NAME"`
    EmailSenderAddress   string        `mapstructure:"EMAIL_SENDER_ADDRESS"`
    EmailSenderPassword  string        `mapstructure:"EMAIL_SENDER_PASSWORD"`
    SMTPHost             string        `mapstructure:"SMTP_HOST"`
    SMTPPort             int           `mapstructure:"SMTP_PORT"`
}

// 加载配置
func LoadConfig(path string) (config Config, err error) {
    viper.AddConfigPath(path)
    viper.SetConfigName("app")
    viper.SetConfigType("env")

    viper.AutomaticEnv()

    err = viper.ReadInConfig()
    if err != nil {
        return
    }

    err = viper.Unmarshal(&config)
    return
}

实践指南：从开发到部署的完整流程

SimpleBank提供了完整的开发、测试和部署流程，使开发者能够快速上手并将系统部署到生产环境。

开发环境搭建

前置工具安装

# 安装Go语言 (1.24+)
sudo apt install golang-go

# 安装Docker和Docker Compose
sudo apt install docker.io docker-compose

# 安装数据库迁移工具
go install -tags 'postgres' github.com/golang-migrate/migrate/v4/cmd/migrate@latest

# 安装SQLC代码生成器
go install github.com/sqlc-dev/sqlc/cmd/sqlc@latest

# 安装Protocol Buffers编译器
sudo apt install protobuf-compiler

# 安装Go protobuf插件
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-grpc-gateway@latest

项目克隆与依赖安装

# 克隆代码仓库
git clone https://gitcode.com/GitHub_Trending/si/simplebank
cd simplebank

# 安装Go依赖
go mod download

环境配置

创建app.env文件配置环境变量：

# 应用环境
ENVIRONMENT=development

# 数据库配置
DB_SOURCE=postgresql://root:secret@localhost:5432/simple_bank?sslmode=disable

# HTTP服务器配置
HTTP_SERVER_ADDRESS=0.0.0.0:8080

# gRPC服务器配置
GRPC_SERVER_ADDRESS=0.0.0.0:9090

# 令牌配置
TOKEN_SYMMETRIC_KEY=your-32-byte-secret-key-here
ACCESS_TOKEN_DURATION=15m
REFRESH_TOKEN_DURATION=720h

# Redis配置
REDIS_ADDRESS=localhost:6379

# 邮件配置
EMAIL_SENDER_NAME=Simple Bank
EMAIL_SENDER_ADDRESS=your-email@example.com
EMAIL_SENDER_PASSWORD=your-email-password
SMTP_HOST=smtp.example.com
SMTP_PORT=587

数据库初始化

# 创建Docker网络
make network

# 启动PostgreSQL和Redis容器
make docker-compose-up

# 创建数据库
make createdb

# 执行数据库迁移
make migrateup

开发工作流

SimpleBank提供了完善的Makefile脚本，简化开发流程：

# 常用开发命令
server:
    go run main.go

test:
    go test -v -cover ./...

sqlc:
    sqlc generate

migrateup:
    migrate -path db/migration -database "$(DB_SOURCE)" -verbose up

migratedown:
    migrate -path db/migration -database "$(DB_SOURCE)" -verbose down

proto:
    protoc --proto_path=proto --go_out=pb --go_opt=paths=source_relative \
        --go-grpc_out=pb --go-grpc_opt=paths=source_relative \
        --grpc-gateway_out=pb --grpc-gateway_opt=paths=source_relative \
        proto/*.proto proto/google/api/*.proto

mock:
    mockgen -package mockdb -destination db/mock/store.go github.com/simplebank/db/sqlc Store

测试策略

项目采用多层次测试策略，确保代码质量：

单元测试：测试独立功能单元
集成测试：测试模块间交互
端到端测试：测试完整业务流程

测试示例：

// api/account_test.go - 账户API测试
func TestGetAccountAPI(t *testing.T) {
    // 创建测试服务器和数据库Mock
    testCases := []struct {
        name          string
        accountID     int64
        setupAuth     func(t *testing.T, request *http.Request, tokenMaker token.Maker)
        buildStubs    func(store *mockdb.MockStore)
        checkResponse func(t *testing.T, recorder *httptest.ResponseRecorder)
    }{
        {
            name:      "OK",
            accountID: 1,
            setupAuth: func(t *testing.T, request *http.Request, tokenMaker token.Maker) {
                addAuthorization(t, request, tokenMaker, authorizationTypeBearer, "user1", time.Minute)
            },
            buildStubs: func(store *mockdb.MockStore) {
                store.EXPECT().GetAccount(gomock.Any(), gomock.Eq(int64(1))).Times(1).Return(db.Account{
                    ID:       1,
                    Owner:    "user1",
                    Balance:  1000,
                    Currency: "USD",
                }, nil)
            },
            checkResponse: func(t *testing.T, recorder *httptest.ResponseRecorder) {
                require.Equal(t, http.StatusOK, recorder.Code)
                var response getAccountResponse
                err := json.Unmarshal(recorder.Body.Bytes(), &response)
                require.NoError(t, err)
                require.Equal(t, int64(1), response.Data.ID)
                require.Equal(t, "user1", response.Data.Owner)
                require.Equal(t, int64(1000), response.Data.Balance)
                require.Equal(t, "USD", response.Data.Currency)
            },
        },
        // 更多测试用例...
    }

    for i := range testCases {
        tc := testCases[i]
        t.Run(tc.name, func(t *testing.T) {
            ctrl := gomock.NewController(t)
            defer ctrl.Finish()

            store := mockdb.NewMockStore(ctrl)
            tc.buildStubs(store)

            server := newTestServer(t, store)
            recorder := httptest.NewRecorder()

            url := fmt.Sprintf("/accounts/%d", tc.accountID)
            request, err := http.NewRequest(http.MethodGet, url, nil)
            require.NoError(t, err)

            tc.setupAuth(t, request, server.tokenMaker)
            server.router.ServeHTTP(recorder, request)
            tc.checkResponse(t, recorder)
        })
    }
}

容器化与部署

SimpleBank提供了完整的容器化配置，支持在本地环境和生产环境部署。

Docker配置

# Dockerfile
FROM golang:1.24-alpine AS builder

WORKDIR /app

COPY . .

RUN go mod download
RUN CGO_ENABLED=0 GOOS=linux go build -o simplebank ./main.go

FROM alpine:3.18

WORKDIR /app

COPY --from=builder /app/simplebank .
COPY --from=builder /app/app.env .

EXPOSE 8080 9090

CMD ["./simplebank"]

Docker Compose配置

# docker-compose.yaml
version: '3.8'

services:
  postgres:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=root
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=simple_bank
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

  api:
    build: .
    ports:
      - "8080:8080"
      - "9090:9090"
    environment:
      - DB_SOURCE=postgresql://root:secret@postgres:5432/simple_bank?sslmode=disable
      - REDIS_ADDRESS=redis:6379
    depends_on:
      - postgres
      - redis

volumes:
  postgres_data:
  redis_data:

Kubernetes部署

对于生产环境，项目提供了Kubernetes部署配置：

# eks/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: simplebank
spec:
  replicas: 3
  selector:
    matchLabels:
      app: simplebank
  template:
    metadata:
      labels:
        app: simplebank
    spec:
      containers:
      - name: simplebank
        image: <your-docker-image>
        ports:
        - containerPort: 8080
        - containerPort: 9090
        env:
        - name: ENVIRONMENT
          value: "production"
        - name: DB_SOURCE
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: source
        - name: TOKEN_SYMMETRIC_KEY
          valueFrom:
            secretKeyRef:
              name: token-secret
              key: symmetric-key
        # 更多环境变量...
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "500m"
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10