Scott

Kratos 项目创建与使用 Demo 3 months ago

微服务
5198个字符
共有27人围观

博客大纲

以下是一个完整的 Kratos 项目创建与使用 Demo，以开发一个简单的 User 微服务为例，涵盖项目初始化、API 定义、业务逻辑编写、数据库操作和运行测试。

1. 环境准备

  • 安装 Go (1.16+)
  • 安装 Kratos CLI： bash go install github.com/go-kratos/kratos/cmd/kratos/v2@latest - 安装依赖工具： bash # Protobuf 编译器 brew install protobuf # Go Protobuf 插件 go install google.golang.org/protobuf/cmd/protoc-gen-go@latest # gRPC 插件 go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest # Kratos 插件 go install github.com/go-kratos/kratos/cmd/protoc-gen-go-http/v2@latest

2. 创建项目

(1) 初始化项目

kratos new user-service
cd user-service

生成的标准目录结构如下：

user-service/
├── api/                # Protobuf 定义
├── internal/           # 核心代码
│   ├── biz/            # 业务逻辑
│   ├── data/           # 数据访问
│   ├── service/        # 服务实现
│   └── conf/           # 配置文件
├── configs/            # 配置文件
└── go.mod

(2) 添加 User 服务 API

在 api/user/v1/user.proto 中定义接口：

syntax = "proto3";

package user.v1;
option go_package = "user-service/api/user/v1;v1";

service User {
  rpc CreateUser (CreateUserRequest) returns (CreateUserReply);
  rpc GetUser (GetUserRequest) returns (GetUserReply);
}

message CreateUserRequest {
  string name = 1;
  string email = 2;
}

message CreateUserReply {
  int64 id = 1;
}

message GetUserRequest {
  int64 id = 1;
}

message GetUserReply {
  int64 id = 1;
  string name = 2;
  string email = 3;
}

(3) 生成代码

# 生成 gRPC/HTTP 代码
kratos proto client api/user/v1/user.proto
# 生成 Service 层代码
kratos proto server api/user/v1/user.proto -t internal/service

3. 实现业务逻辑

(1) 定义领域实体（biz 层）

在 internal/biz/user.go 中定义 User 实体和 Repo 接口：

package biz

import "context"

type User struct {
    ID    int64
    Name  string
    Email string
}

type UserRepo interface {
    Save(context.Context, *User) (*User, error)
    FindByID(context.Context, int64) (*User, error)
}

(2) 实现数据访问（data 层）

在 internal/data/user.go 中实现 UserRepo（使用 GORM）：

package data

import (
    "user-service/internal/biz"
    "gorm.io/gorm"
)

type userRepo struct {
    db *gorm.DB
}

func NewUserRepo(db *gorm.DB) biz.UserRepo {
    return &userRepo{db: db}
}

func (r *userRepo) Save(ctx context.Context, u *biz.User) (*biz.User, error) {
    if err := r.db.Create(u).Error; err != nil {
        return nil, err
    }
    return u, nil
}

func (r *userRepo) FindByID(ctx context.Context, id int64) (*biz.User, error) {
    var u biz.User
    if err := r.db.First(&u, id).Error; err != nil {
        return nil, err
    }
    return &u, nil
}

(3) 注册依赖（data 层）

在 internal/data/data.go 中初始化数据库：

package data

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

type Data struct {
    db *gorm.DB
}

func NewDB(conf *conf.Data) (*gorm.DB, error) {
    db, err := gorm.Open(mysql.Open(conf.Database.Source))
    if err != nil {
        return nil, err
    }
    return db, nil
}

(4) 实现 Service 层

在 internal/service/user.go 中调用 biz 层：

package service

import (
    "context"
    "user-service/internal/biz"
    v1 "user-service/api/user/v1"
)

type UserService struct {
    v1.UnimplementedUserServer
    uc *biz.UserUseCase
}

func NewUserService(uc *biz.UserUseCase) *UserService {
    return &UserService{uc: uc}
}

func (s *UserService) CreateUser(ctx context.Context, req *v1.CreateUserRequest) (*v1.CreateUserReply, error) {
    user, err := s.uc.Create(ctx, &biz.User{Name: req.Name, Email: req.Email})
    if err != nil {
        return nil, err
    }
    return &v1.CreateUserReply{Id: user.ID}, nil
}

4. 依赖注入（Wire）

(1) 在 internal/biz 中定义 ProviderSet

// internal/biz/provider.go
var ProviderSet = wire.NewSet(NewUserUseCase)

(2) 生成依赖注入代码

# 安装 Wire
go install github.com/google/wire/cmd/wire@latest
# 生成依赖注入代码
wire gen ./cmd/user-service

5. 配置与运行

(1) 修改配置文件 configs/config.yaml

server:
  http:
    addr: 0.0.0.0:8000
  grpc:
    addr: 0.0.0.0:9000
data:
  database:
    source: "root:password@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True&loc=Local"

(2) 启动服务

# 编译并运行
kratos run

6. 测试接口

(1) HTTP 接口测试

# 创建用户
curl -X POST http://localhost:8000/user/v1/users \
  -H "Content-Type: application/json" \
  -d '{"name":"Alice", "email":"alice@example.com"}'

# 查询用户
curl http://localhost:8000/user/v1/users/1

(2) gRPC 接口测试

使用 grpcurl：

grpcurl -plaintext -d '{"id":1}' localhost:9000 user.v1.User/GetUser

完整项目结构

user-service/
├── api/
│   └── user/v1/user.proto
├── internal/
│   ├── biz/            # User 实体和 UseCase
│   ├── data/           # GORM 实现
│   └── service/        # gRPC 服务实现
├── configs/            # 配置文件
└── cmd/               # 主入口

关键点总结

  1. 分层清晰：biz 处理业务逻辑，data 处理持久化，service 实现 gRPC/HTTP 接口。
  2. 依赖注入：通过 wire 自动管理 Repo、UseCase 等依赖。
  3. 快速开发：kratos proto 工具生成基础代码，减少重复工作。

通过这个 Demo，你可以快速上手 Kratos 的核心开发流程。进一步学习可以参考 Kratos 官方示例。