Kratos和Kitex
Kratos与Kitex框架开发指导文档
目录
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
1. 框架概述
1.1 Kratos框架
Kratos是B站开源的云原生微服务框架，设计理念先进，支持全链路治理，适合中大型云原生项目。
核心特性：
●
基于Protobuf定义API
●
内置gRPC和HTTP服务
●
支持服务注册发现
●
提供丰富的中间件
●
完善的错误处理机制
1.2 Kitex框架
Kitex是字节跳动开源的高性能RPC框架，采用自研网络库Netpoll，在超大规模微服务集群中表现优异。
核心特性：
●
高性能网络编程模型
●
支持多协议多消息类型
●
强大的扩展性
●
内置服务治理能力
●
完善的监控指标
2. 环境准备
2.1 基础环境
# Go环境go version # 推荐1.18+
export GOPROXY=https://goproxy.cn,direct
export GO111MODULE=on
# Protobuf工具
brew install protobuf # macOS
# 或
sudo apt-get install protobuf-compiler # Linux
2.2 框架工具安装
# Kratos工具go install github.com/go-kratos/kratos/cmd/kratos/v2@latest
# Kitex工具
go install github.com/cloudwego/kitex/tool/cmd/kitex@latest
go install github.com/cloudwego/thriftgo@latest
3. Kratos框架详解
3.1 项目初始化
# 创建项目kratos new helloworld
cd helloworld
# 安装依赖
go mod tidy
3.2 项目结构
helloworld/├── api/ # API定义
├── cmd/ # 主程序入口
├── internal/ # 内部实现
│ ├── biz/ # 业务逻辑
│ ├── conf/ # 配置文件
│ ├── data/ # 数据访问
│ ├── server/ # 服务实现
│ └── service/ # 服务接口
├── scripts/ # 脚本文件
└── go.mod # Go模块
3.3 服务定义
// api/helloworld/v1/helloworld.protosyntax = "proto3";
package helloworld.v1;
option go_package = "helloworld/api/helloworld/v1";
service Greeter {
rpc SayHello (HelloRequest) returns (HelloReply);
}
message HelloRequest {
string name = 1;
}
message HelloReply {
string message = 1;
}
3.4 服务实现
// internal/service/greeter.gopackage service
import (
"context"
"helloworld/api/helloworld/v1"
)
type GreeterService struct {
v1.UnimplementedGreeterServer
}
func (s *GreeterService) SayHello(ctx context.Context, req *v1.HelloRequest) (*v1.HelloReply, error) {
return &v1.HelloReply{
Message: "Hello " + req.Name,
}, nil
}
4. Kitex框架详解
4.1 IDL定义
// idl/example.thriftnamespace go api
struct Request {
1: string message
}
struct Response {
1: string message
}
service Example {
Response Echo(1: Request req)
}
4.2 代码生成
# 生成Kitex代码kitex -module example -service example idl/example.thrift
4.3 服务实现
// handler/example.gopackage handler
import (
"context"
"example/api"
)
type Example struct{}
func (e *Example) Echo(ctx context.Context, req *api.Request) (resp *api.Response, err error) {
return &api.Response{
Message: "Echo: " + req.Message,
}, nil
}
4.4 服务启动
// main.gopackage main
import (
"example/kitex_gen/example/api"
"example/handler"
"github.com/cloudwego/kitex/server"
)
func main() {
svr := api.NewServer(
new(handler.Example),
server.WithServerBasicInfo(&rpcinfo.EndpointBasicInfo{
ServiceName: "example",
}),
server.WithListenAddr(":8888"),
)
svr.Run()
}
5. 项目结构规范
5.1 Kratos项目结构
// 推荐的Kratos项目结构project/
├── api/ # API定义
│ └── v1/ # 版本控制
├── cmd/ # 命令行工具
│ └── app/ # 主程序
├── internal/
│ ├── biz/ # 业务逻辑层
│ ├── data/ # 数据访问层
│ │ ├── dao/ # 数据访问对象
│ │ └── db/ # 数据库连接
│ ├── server/ # 服务配置
│ │ ├── grpc/ # gRPC服务
│ │ └── http/ # HTTP服务
│ └── service/ # 服务实现
├── pkg/ # 公共包
├── scripts/ # 脚本文件
├── configs/ # 配置文件
└── go.mod
5.2 Kitex项目结构
// 推荐的Kitex项目结构project/
├── idl/ # IDL定义
├── kitex_gen/ # 生成代码
├── handler/ # 服务处理
├── pkg/ # 公共包
├── scripts/ # 脚本文件
├── configs/ # 配置文件
└── main.go
6. 服务开发实践
6.1 Kratos服务开发
// internal/biz/greeter.gopackage biz
import (
"context"
"helloworld/api/helloworld/v1"
)
type GreeterUsecase struct {
repo GreeterRepo
}
func (uc *GreeterUsecase) CreateGreeter(ctx context.Context, g *v1.Greeter) error {
return uc.repo.Save(ctx, g)
}
func (uc *GreeterUsecase) GetGreeter(ctx context.Context, id int64) (*v1.Greeter, error) {
return uc.repo.FindByID(ctx, id)
}
6.2 Kitex服务开发
// handler/user.gopackage handler
import (
"context"
"user/api"
"user/service"
)
type User struct {
userService *service.UserService
}
func (u *User) GetUser(ctx context.Context, req *api.GetUserRequest) (*api.GetUserResponse, error) {
user, err := u.userService.GetUserByID(req.Id)
if err != nil {
return nil, err
}
return &api.GetUserResponse{
User: &api.User{
Id: user.ID,
Name: user.Name,
},
}, nil
}
7. 配置管理
7.1 Kratos配置
# configs/application.ymlserver:
http:
addr: 0.0.0.0:8000
timeout: 1s
grpc:
addr: 0.0.0.0:9000
timeout: 1s
data:
database:
driver: mysql
source: "user:pass@tcp(127.0.0.1:3306)/dbname"
7.2 Kitex配置
# configs/kitex.ymlserver:
addr: ":8888"
network: "tcp"
max_connections: 10000
keepalive: 60s
client:
timeout: 1s
retry:
max_attempts: 3
8. 数据库操作
8.1 Kratos使用GORM
// internal/data/db/db.gopackage db
import (
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
func NewDB(cfg *Data) (*gorm.DB, error) {
db, err := gorm.Open(mysql.Open(cfg.Database.Source), &gorm.Config{})
if err != nil {
return nil, err
}
return db, nil
}
8.2 Kitex数据库集成
// pkg/db/mysql.gopackage db
import (
"database/sql"
_ "github.com/go-sql-driver/mysql"
)
var DB *sql.DB
func InitDB(dsn string) error {
var err error
DB, err = sql.Open("mysql", dsn)
if err != nil {
return err
}
return DB.Ping()
}
9. API设计规范
9.1 Protobuf设计原则
// 命名规范message CreateUserRequest {
string username = 1; // 小写蛇形命名
string email = 2;
int32 age = 3;
}
message UserResponse {
int64 id = 1; // ID使用int64
string username = 2;
string email = 3;
int32 age = 4;
int64 created_at = 5; // 时间戳使用int64
int64 updated_at = 6;
}
9.2 错误码设计
// 错误码枚举enum ErrorCode {
SUCCESS = 0;
INVALID_PARAMS = 400;
UNAUTHORIZED = 401;
FORBIDDEN = 403;
NOT_FOUND = 404;
INTERNAL_ERROR = 500;
SERVICE_UNAVAILABLE = 503;
}
10. 日志与监控
10.1 Kratos日志
// internal/service/user.goimport "github.com/go-kratos/kratos/v2/log"
type UserService struct {
log *log.Helper
}
func NewUserService(logger log.Logger) *UserService {
return &UserService{
log: log.NewHelper(logger),
}
}
func (s *UserService) GetUser(ctx context.Context, id int64) (*User, error) {
s.log.WithContext(ctx).Infof("get user by id: %d", id)
// 业务逻辑
return user, nil
}
10.2 Kitex监控
// metrics配置import "github.com/cloudwego/kitex/pkg/metrics"
func main() {
svr := api.NewServer(
new(handler.Example),
server.WithMetrics(metrics.NewPrometheusMetrics()),
)
svr.Run()
}
11. 测试策略
11.1 Kratos单元测试
// internal/biz/greeter_test.gopackage biz
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
)
func TestGreeterUsecase_CreateGreeter(t *testing.T) {
// mock repo
mockRepo := new(MockGreeterRepo)
uc := &GreeterUsecase{repo: mockRepo}
// 测试用例
err := uc.CreateGreeter(context.Background(), &v1.Greeter{Name: "test"})
assert.NoError(t, err)
}
11.2 Kitex集成测试
// handler/user_test.gopackage handler
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
)
func TestUser_GetUser(t *testing.T) {
userHandler := &User{
userService: mockUserService,
}
resp, err := userHandler.GetUser(context.Background(), &api.GetUserRequest{Id: 1})
assert.NoError(t, err)
assert.Equal(t, "test", resp.User.Name)
}
12. 部署方案
12.1 Docker部署
# Kratos DockerfileFROM golang:1.18-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o /helloworld cmd/app/main.go
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /helloworld .
EXPOSE 8000 9000
CMD ["./helloworld"]
12.2 Kubernetes部署
# k8s deployment.yamlapiVersion: apps/v1
kind: Deployment
metadata:
name: helloworld
spec:
replicas: 3
selector:
matchLabels:
app: helloworld
template:
metadata:
labels:
app: helloworld
spec:
containers:
- name: helloworld
image: your-registry/helloworld:latest
ports:
- containerPort: 8000
- containerPort: 9000
resources:
requests:
memory: "64Mi"
cpu: "250m"
limits:
memory: "128Mi"
cpu: "500m"
总结
Kratos和Kitex都是优秀的Go微服务框架，选择时应考虑：
选择Kratos的场景：
●
需要完整的云原生解决方案
●
项目规模中大型
●
重视开发效率和生态完善度
●
需要HTTP和gRPC双协议支持
选择Kitex的场景：
●
对性能要求极高
●
已有Thrift IDL定义
●
需要深度定制网络层
无论选择哪个框架，都应遵循统一的开发规范，注重代码质量，完善测试覆盖，确保服务的稳定性和可维护性。
本文档持续更新，建议定期查看最新版本
- 感谢你赐予我前进的力量
-
微信 
支付宝
