微服务
边学边写的Demo:LearningDemo
概念解析
区别于单体架构,微服务是一种分布式架构模式
单体架构

单体架构就是数据库,缓存等一系列组件都在一台机器上面开发,运行和部署的架构
单体应用的优点
- 开发效率高:功能都在单个程序内部,便于软件设计和开发规划
- 容易部署成本低:程序单一不存在分布式集群的复杂部署环境,降低了部署难度
- 容易测试:没有各种复杂的服务调用关系,都是内部调用方便测试
单体架构的缺点就是,在数据,缓存,文件等不断增多的情况下,一台服务器资源有限经受不了这种压力,于是就提出了一种分布式的解决方案
分布式设计

这种设计将各个服务都部署到不同的机器上面进行运行,这样各个服务之间不会进行资源的竞争,压力就小了很多
但是在这种情况下面就会出现一个问题:由于机器部署了多台,每个服务都可能出现宕机的情况,于是提出了集群在保障了基本的高可用
集群

我们可以部署多台不同的机器跑相同的服务,再通过合理的负载均衡策略,将请求分散到不同的服务器上面,这样的话就保障了一定的高可用,比如我们有两台机器,如果即使其中的一台机器挂掉,另一台机器也可以承担整个请求的任务
但是当前的集群也会有一个新的问题:比如这里的服务ABC,每个服务的请求量和业务复杂度都是不同的,那么就会出现有一些服务的请求和复杂度特别高,那么我们就会对一些服务进行拆分更微小的服务,降低耦合度,这样就形成了我们的微服务
微服务架构

从单体整个应用程序开始进行拆分,拆分为多个服务,并根据每个服务各自的特点拆分成更微小的服务,最终就成就了我们的微服务。在微服务前有一个网关,通过负载均衡和nginx反向代理进入我们的网关,通过网关会找到我们相关的服务
但是微服务这种设计结构在提升系统高可用性,强可拓展性和易维护性的同时,也会大大增加整个项目的复杂度和设计难度
在项目中理解微服务
经过上面的了解,我们可以知道在一个微服务项目中,是应该有网关和多个微服务模块存在的,除此之外,还有
两个重要的工具,也是实现微服务的核心技术:rpc客户端(Client)和rpc服务端(Server)
rpc客户端Client负责接受api网关的rpc请求并将其序列化,发送给rpc服务端Server,而rpc服务端Server就根据具体业务逻辑执行相应代码再将相应返回给Client
所以说,微服务与微服务之间是Client-Server的关系,理解这一点很重要,这意味着微服务之间可以相互调用,并且应当避免耦合
微服务的拆分

在服务拆分的时候,难带是拆分得越细越好吗?
当一个项目拆分的时候,拆分的服务越多,从理论上来说它的可维护性也就越好,与此同时拆分得越细,需要得团队人数就越多,项目得复杂度也就越高,设计难度也会大的多
常见的拆分逻辑
- 系统维度拆分:根据系统一类功能聚集在一起的模块进行拆分,系统维度是最基本的拆分单位。
- 功能维度拆分:针对一些复杂度较高或重要的功能进行拆分。
- 读写维度拆分:针对数据操作存在较大读写差的功能或模块进行拆分
微服务的实现
一个请求访问微服务的流程如下
http客户端发送请求,服务器api网关(hertz/gin)解析http请求,构造rpc请求发送给内部rpc客户端(手脚架生成),rpc客户端通过网络传输(序列化)调用rpc服务端(手脚架生成)(反序列化),rpc服务端进入内部业务代码处理业务逻辑,再原路返回响应
HTTP客户端 (curl/浏览器)
↓ POST /register
API网关 (Hertz)
↓ 解析HTTP请求,调用RPC
RPC客户端 (Kitex生成)
↓ 序列化请求,发送到8888端口
网络传输
↓
RPC服务端 (Kitex生成,在8888端口监听)
↓ 接收请求,反序列化
你的业务代码 (handler.go)
↓ 处理注册逻辑
返回响应
↓
RPC服务端 → 序列化响应 → 网络 → RPC客户端 → API网关 → HTTP响应接下来,我们将对各个概念和更加详细的技术进行解释
rpc
rpc是什么?
定义:是一种用于不同计算机之间通信的协议。它允许一个计算机程序调用另一个计算机上的函数或者方法
在单体架构中,我们只需要得到这个服务对象就可以调用其方法,但是在服务拆分之后变成了两台机器,就不能这样调用了,那应该怎么办呢?
我们知道,微服务设计就是将不同的服务设计在不同的服务器上单独运行,此时服务间的信息传递和调用就变得更加困难,此时就需要用到rpc通信机制,通过在当前服务上调用其他服务器注册的网关,实现像单体架构一样直接调用其方法
所以rpc的存在就是把远程的服务调用变得跟本地类似
但是问题又来了,我们在通过rpc调用其他服务器的服务时,怎么定位需要调用的服务的呢?
除了显式注册ip:port外,我们通常使用注册中心来解决这个问题,也涉及到了服务注册和服务发现
注册中心

注册中心(register)就是服务信息的存储器,存储记录了每个注册微服务网络地址等信息(微服务的ServiceName、IP、Port、MetaData等),常用的注册中心如etcd,concul
服务注册
每个微服务在启动时,将自己的网络地址等信息注册到注册中心,由注册中心存储这些数据
定时续期
定时续期(keep alive),定期告诉 Service Registry 自己还在,能够继续服务
健康检查
主动探测:注册中心定期调用服务的健康检查接口。
心跳机制:服务定期发送心跳包,超时未收到则标记实例为不健康
如etcd,使用租约健康机制,主程序要定时keep alive确保注册中心存活,若注册中心失活就再次进行服务注册
服务消费者从注册中心查询服务提供者的地址,并通过该地址调用服务提供者的接口
服务发现
服务发现的方式一般有两种:
- 拉取的方式:服务消费方(Consumer)主动向注册中心发起服务查询的请求。
- 推送的方式:服务订阅/通知变更(下发):服务消费方(Consumer)主动向注册中心订阅某个服务,当注册中心中该服务信息发生变更时,注册中心主动通知消费者
服务治理
服务治理,在基础的微服务项目上确保微服务系统的稳定性、可靠性和可观测性
常见的服务治理包括
- 负载均衡
- 熔断与降级
- 限流:计数器,滑动窗口,漏桐,令牌桶
- 重试与超时
- redis集群
消息队列
上面所说的rpc通信方式属于同步通信,而此处的消息队列便是异步通信,可用于解耦服务依赖
应用场景:
- 异步处理
- 应用解耦
- 流量削峰
- 最终一致性
主流消息队列:
Kafka:高吞吐,适合日志、流处理
RabbitMQ:功能丰富,适合复杂路由
RocketMQ:阿里出品,事务消息强
nsq:go原生实现
分布式事务
在微服务中,可能存在多个服务争夺跨服务数据的情况,因此在微服务架构中,保证跨服务的数据一致性是巨大挑战,此时就要用到分布式事务来确保事务一致性
dtm: GitHub - dtm-labs/dtm: A distributed transaction framework, supports workflow, saga, tcc, xa, 2-phas
可观测性
在单体式架构中,我们常用日志进行项目观察,但是对于微服务而言,给每个微服务分配日志再查询是不现实也不方便的,此时我们就需要用到可观测性三巨头:指标(Metrics)、链路追踪(Tracing)、分布式日志(Logging)
指标(Metrics)
四个黄金指标
- 延迟(Latency):请求处理时间
- 流量(Traffic):请求量/QPS
- 错误(Errors):错误率
- 饱和度(Saturation):资源使用率
链路追踪(Tracing)
分布式请求跟踪,分析请求在系统中的完整路径。
OpenTelemetry标准:
- Trace:一次请求的完整路径
- Span:单个服务内的操作单元
- Context:传递跟踪信息
分布式日志(Logging)
集中收集、存储和查询分布式系统的日志。
ELK Stack:
- Elasticsearch:存储和检索
- Logstash:收集和解析
- Kibana:可视化
微服务框架
接下来,我们进行微服务的基础代码实现
常用两个微服务框架:go-zero和kitex,此处详细介绍kitex
go-zero
go-zero是万俊峰开发的Go微服务框架,集成了各种工程实践
核心特性:
- 内置代码生成工具
- 内置服务治理
- 声明式API开发
- 高性能RPC框架
架构组件:
- REST/RPC服务框架
- API网关
- 配置中心
- 任务调度
- 缓存管理
kitex
Kitex是字节跳动开源的Go微服务RPC框架,已在字节内部大规模使用
核心优势:
- 极致性能:基于Netpoll网络库,性能领先
- 扩展性强:支持多协议、可扩展传输层
- 服务治理:内置服务发现、负载均衡、熔断等
- 代码生成:强大IDL代码生成能力
- 云原生:原生支持K8s、服务网格
用kitex快速搭建基础微服务demo
kitex支持从IDL文件自动生成rpc客户端/服务端
一下以最基础的demo为例,实现支持用户注册功能的微服务demo
安装依赖和必要工具
# 安装Kitex代码生成工具
go install github.com/cloudwego/kitex/tool/cmd/kitex@latest
# 安装Thriftgo(用于Thrift IDL)
go install github.com/cloudwego/thriftgo@latest
# 验证安装
kitex --version
thriftgo --version项目目录和结构
kitexDemo/
├── api-gateway/
│ ├── main.go # 主入口
│ ├── router.go # 路由定义
│ └── http.go # HTTP处理器
├── user-service/
│ ├── main.go # RPC服务入口
│ └── handler.go # 业务逻辑
└── idl/
├── kitex_gen/
│ └── user/ # 生成代码,以下略
└── user.thrift # 接口定义编写IDL文件
IDL(接口定义语言)定义了服务接口和数据结构,是RPC通信的契约
//idl/user.thrift
namespace go user
//用户注册请求
struct RegisterReq {
1: string username
2: string password
}
//用户注册响应
struct RegisterResp {
1: bool success
2: string message
}
//用户服务接口
service UserService {
RegisterResp Register(1: RegisterReq req)
}代码生成
# 初始化Go模块
go mod init
# 生成Kitex代码
kitex -module project_name idl/user.thriftkitex框架会自动根据thrift文件生成rpc代码
再分别进入各自的目录中,执行如下命令生成代码:
(可选)
// item 目录下执行
kitex -module project_name -service service_name -use ../kitex_gen ../idl/user.thrift这样kitex就会在我们的服务模块中生成main和hanlder代码框架以及启动脚本和kitex配置
编写rpc业务逻辑代码
//user-service/handler.go
package main
import (
"context"
"microservicesDemo/L2-kitex/kitex_gen/user"
)
// UserServiceImpl 实现Kitex生成的接口
type UserServiceImpl struct{}
func (s *UserServiceImpl) Register(ctx context.Context, req *user.RegisterReq) (*user.RegisterResp, error) {
if req.Username == "" || req.Password == "" {
return &user.RegisterResp{
Success: false,
Message: "用户名、密码、邮箱不能为空",
}, nil
}
if len(req.Username) < 3 {
return &user.RegisterResp{
Success: false,
Message: "用户名至少3个字符",
}, nil
}
return &user.RegisterResp{
Success: true,
Message: "注册成功",
}, nil
}
编写rpc服务启动代码
//user-service/main.go
package main
import (
"microservicesDemo/L2-kitex/kitex_gen/user/userservice"
"net"
"github.com/cloudwego/kitex/server"
)
func main() {
// 创建地址
addr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8080")
if err != nil {
panic(err)
}
svr := userservice.NewServer(
new(UserServiceImpl), // 业务处理器
server.WithServiceAddr(addr), // 监听端口
)
//启动rpc服务
err = svr.Run()
if err != nil {
panic(err)
}
}编写api网关代码
编写api代码
//api-gateway/main.go
package main
import (
"log"
"microservicesDemo/L2-kitex/kitex_gen/user/userservice"
"github.com/cloudwego/hertz/pkg/app/server" // Hertz服务器
"github.com/cloudwego/kitex/client" // Kitex客户端
)
// 全局RPC客户端
var userClient userservice.Client
// init函数,在main之前执行
func init() {
log.Println("初始化rpc客户端...")
// 创建kitex客户端
var err error
userClient, err = userservice.NewClient("user-service", client.WithHostPorts("127.0.0.1:8080"))
if err != nil {
log.Fatal("创建客户端失败", err)
}
log.Println("RPC客户端初始化成功")
log.Println("连接到: 127.0.0.1:8888")
}
func main() {
h := server.Default(server.WithHostPorts(":8888"))
handler := APIHandler{}
RegisterRoutes(h, handler)
log.Printf("网关服务器正在端口 8888 上启动")
h.Spin()
}//api-gateway/router
package main
import (
"github.com/cloudwego/hertz/pkg/app/server"
)
func RegisterRoutes(srv *server.Hertz, handler APIHandler) {
user := srv.Group("/user")
user.POST("/register", handler.Register)
}
//api-gateway/http.go
package main
import (
"context"
"log"
"microservicesDemo/L2-kitex/kitex_gen/user"
"time"
"github.com/cloudwego/hertz/pkg/app"
"github.com/cloudwego/hertz/pkg/common/utils"
)
type APIHandler struct {
}
func NewAPIHandler() *APIHandler {
return &APIHandler{}
}
func (h *APIHandler) Register(c context.Context, ctx *app.RequestContext) {
// 常规handler
startTime := time.Now()
var req struct {
Username string `json:"username"`
Password string `json:"password"`
}
if err := ctx.BindAndValidate(&req); err != nil {
log.Println("绑定参数时发生错误", err)
ctx.JSON(400, utils.H{
"code": 400,
"msg": "绑定参数时发生错误",
})
return
}
// 构造rpc请求,包名为构建时填写的包名
rpcReq := &user.RegisterReq{
Username: req.Username,
Password: req.Password,
}
// 调用rpc请求
log.Println("调用rpc服务...")
rpcResp, err := userClient.Register(c, rpcReq)
if err != nil {
log.Printf("RPC调用失败: %v", err)
ctx.JSON(500, utils.H{
"code": 500,
"message": "服务内部错误: " + err.Error(),
})
return
}
// 判断rpc服务成功与否
statusCode := 200
if !rpcResp.Success {
statusCode = 400
}
duration := time.Since(startTime)
// 返回HTTP响应
log.Printf("注册处理完成,状态码: %d,耗时: %v", statusCode, duration)
ctx.JSON(statusCode, utils.H{
"code": statusCode, // HTTP状态码
"success": rpcResp.Success, // 业务是否成功
"message": rpcResp.Message, // 业务消息
})
}

评论
留言与讨论 ↗欢迎留下想法或问题。这里承接旧站已有评论。
正在加载评论…