快速构建高并发微服务-低调大师

快速构建高并发微服务

2020-08-30 541

0. 为什么说做好微服务很难？

要想做好微服务，我们需要理解和掌握的知识点非常多，从几个维度上来说：

基本功能层面
1. 并发控制&限流，避免服务被突发流量击垮
2. 服务注册与服务发现，确保能够动态侦测增减的节点
3. 负载均衡，需要根据节点承受能力分发流量
4. 超时控制，避免对已超时请求做无用功
5. 熔断设计，快速失败，保障故障节点的恢复能力
高阶功能层面
1. 请求认证，确保每个用户只能访问自己的数据
2. 链路追踪，用于理解整个系统和快速定位特定请求的问题
3. 日志，用于数据收集和问题定位
4. 可观测性，没有度量就没有优化

对于其中每一点，我们都需要用很长的篇幅来讲述其原理和实现，那么对我们后端开发者来说，要想把这些知识点都掌握并落实到业务系统里，难度是非常大的，不过我们可以依赖已经被大流量验证过的框架体系。go-zero微服务框架就是为此而生。

另外，我们始终秉承工具大于约定和文档的理念。我们希望尽可能减少开发人员的心智负担，把精力都投入到产生业务价值的代码上，减少重复代码的编写，所以我们开发了goctl工具。

下面我通过短链微服务来演示通过go-zero快速的创建微服务的流程，走完一遍，你就会发现：原来编写微服务如此简单！

1. 什么是短链服务？

短链服务就是将长的URL网址，通过程序计算等方式，转换为简短的网址字符串。

写此短链服务是为了从整体上演示go-zero构建完整微服务的过程，算法和实现细节尽可能简化了，所以这不是一个高阶的短链服务。

2. 短链微服务架构图

这里把shorten和expand分开为两个微服务，并不是说一个远程调用就需要拆分为一个微服务，只是为了最简演示多个微服务而已
后面的redis和mysql也是共用的，但是在真正项目里要尽可能每个微服务使用自己的数据库，数据边界要清晰

3. 准备工作

安装etcd, mysql, redis
准备goctl工具
直接从https://github.com/tal-tech/go-zero/releases下载最新版，后续会加上自动更新
- 也可以从源码编译，在任意目录下进行，目的是为了编译goctl工具
  1. git clone https://github.com/tal-tech/go-zero
  2. 在tools/goctl目录下编译goctl工具go build goctl.go
  3. 将生成的goctl放到$PATH下，确保goctl命令可运行
创建工作目录shorturl
在shorturl目录下执行go mod init shorturl初始化go.mod

4. 编写API Gateway代码

通过goctl生成shorturl.api并编辑，为了简洁，去除了文件开头的info，代码如下：
```
type (
	shortenReq struct {
		url string `form:"url"`
	}

	shortenResp struct {
		shortUrl string `json:"shortUrl"`
	}
)

type (
	expandReq struct {
		key string `form:"key"`
	}

	expandResp struct {
		url string `json:"url"`
	}
)

service shorturl-api {
	@server(
		handler: ShortenHandler
	)
	get /shorten(shortenReq) returns(shortenResp)

	@server(
		handler: ExpandHandler
	)
	get /expand(expandReq) returns(expandResp)
}
```
type用法和go一致，service用来定义get/post/head/delete等api请求，解释如下：
- service shorturl-api {这一行定义了service名字
- @server部分用来定义server端用到的属性
- handler定义了服务端handler名字
- get /shorten(shortenReq) returns(shortenResp)定义了get方法的路由、请求参数、返回参数等

使用goctl生成API Gateway代码

goctl api go -api shorturl.api -dir api

生成的文件结构如下：

.
├── api
│   ├── etc
│   │   └── shorturl-api.yaml         // 配置文件
│   ├── internal
│   │   ├── config
│   │   │   └── config.go             // 定义配置
│   │   ├── handler
│   │   │   ├── expandhandler.go      // 实现expandHandler
│   │   │   ├── routes.go             // 定义路由处理
│   │   │   └── shortenhandler.go     // 实现shortenHandler
│   │   ├── logic
│   │   │   ├── expandlogic.go        // 实现ExpandLogic
│   │   │   └── shortenlogic.go       // 实现ShortenLogic
│   │   ├── svc
│   │   │   └── servicecontext.go     // 定义ServiceContext
│   │   └── types
│   │       └── types.go              // 定义请求、返回结构体
│   └── shorturl.go                   // main入口定义
├── go.mod
├── go.sum
└── shorturl.api

启动API Gateway服务，默认侦听在8888端口

go run api/shorturl.go -f api/etc/shorturl-api.yaml

测试API Gateway服务

curl -i "http://localhost:8888/shorten?url=http://www.xiaoheiban.cn"

返回如下：

HTTP/1.1 200 OK
Content-Type: application/json
Date: Thu, 27 Aug 2020 14:31:39 GMT
Content-Length: 15

{"shortUrl":""}

可以看到我们API Gateway其实啥也没干，就返回了个空值，接下来我们会在rpc服务里实现业务逻辑

可以修改internal/svc/servicecontext.go来传递服务依赖（如果需要）
实现逻辑可以修改internal/logic下的对应文件
可以通过goctl生成各种客户端语言的api调用代码
到这里，你已经可以通过goctl生成客户端代码给客户端同学并行开发了，支持多种语言，详见文档

5. 编写shorten rpc服务

在rpc/shorten目录下编写shorten.proto文件

可以通过命令生成proto文件模板

goctl rpc template -o shorten.proto

修改后文件内容如下：

syntax = "proto3";

package shorten;

message shortenReq {
    string url = 1;
}

message shortenResp {
    string key = 1;
}

service shortener {
    rpc shorten(shortenReq) returns(shortenResp);
}

用goctl生成rpc代码，在rpc/shorten目录下执行命令

goctl rpc proto -src shorten.proto

文件结构如下：

rpc/shorten
├── etc
│   └── shorten.yaml               // 配置文件
├── internal
│   ├── config
│   │   └── config.go              // 配置定义
│   ├── logic
│   │   └── shortenlogic.go        // rpc业务逻辑在这里实现
│   ├── server
│   │   └── shortenerserver.go     // 调用入口, 不需要修改
│   └── svc
│       └── servicecontext.go      // 定义ServiceContext，传递依赖
├── pb
│   └── shorten.pb.go
├── shorten.go                     // rpc服务main函数
├── shorten.proto
└── shortener
    ├── shortener.go               // 提供了外部调用方法，无需修改
    ├── shortener_mock.go          // mock方法，测试用
    └── types.go                   // request/response结构体定义

直接可以运行，如下：

$ go run shorten.go -f etc/shorten.yaml
Starting rpc server at 127.0.0.1:8080...

etc/shorten.yaml文件里可以修改侦听端口等配置

6. 编写expand rpc服务

在rpc/expand目录下编写expand.proto文件

可以通过命令生成proto文件模板

goctl rpc template -o expand.proto

修改后文件内容如下：

syntax = "proto3";

package expand;

message expandReq {
    string key = 1;
}

message expandResp {
    string url = 1;
}

service expander {
    rpc expand(expandReq) returns(expandResp);
}

用goctl生成rpc代码，在rpc/expand目录下执行命令

goctl rpc proto -src expand.proto

文件结构如下：

rpc/expand
├── etc
│   └── expand.yaml                // 配置文件
├── expand.go                      // rpc服务main函数
├── expand.proto
├── expander
│   ├── expander.go                // 提供了外部调用方法，无需修改
│   ├── expander_mock.go           // mock方法，测试用
│   └── types.go                   // request/response结构体定义
├── internal
│   ├── config
│   │   └── config.go              // 配置定义
│   ├── logic
│   │   └── expandlogic.go         // rpc业务逻辑在这里实现
│   ├── server
│   │   └── expanderserver.go      // 调用入口, 不需要修改
│   └── svc
│       └── servicecontext.go      // 定义ServiceContext，传递依赖
└── pb
    └── expand.pb.go

修改etc/expand.yaml里面的ListenOn的端口为8081，因为8080已经被shorten服务占用了

修改后运行，如下：

$ go run expand.go -f etc/expand.yaml
Starting rpc server at 127.0.0.1:8081...

etc/expand.yaml文件里可以修改侦听端口等配置

7. 修改API Gateway代码调用shorten/expand rpc服务

修改配置文件shorter-api.yaml，增加如下内容

Shortener:
  Etcd:
    Hosts:
      - localhost:2379
    Key: shorten.rpc
Expander:
  Etcd:
    Hosts:
      - localhost:2379
    Key: expand.rpc

通过etcd自动去发现可用的shorten/expand服务

修改internal/config/config.go如下，增加shorten/expand服务依赖

type Config struct {
	rest.RestConf
	Shortener rpcx.RpcClientConf     // 手动代码
	Expander  rpcx.RpcClientConf     // 手动代码
}

修改internal/svc/servicecontext.go，如下：

type ServiceContext struct {
	Config    config.Config
	Shortener rpcx.Client                                 // 手动代码
	Expander  rpcx.Client                                 // 手动代码
}

func NewServiceContext(config config.Config) *ServiceContext {
	return &ServiceContext{
		Config:    config,
		Shortener: rpcx.MustNewClient(config.Shortener),    // 手动代码
		Expander:  rpcx.MustNewClient(config.Expander),     // 手动代码
	}
}

通过ServiceContext在不同业务逻辑之间传递依赖

修改internal/logic/expandlogic.go，如下：

type ExpandLogic struct {
	ctx context.Context
	logx.Logger
	expander rpcx.Client            // 手动代码
}

func NewExpandLogic(ctx context.Context, svcCtx *svc.ServiceContext) ExpandLogic {
	return ExpandLogic{
		ctx:    ctx,
		Logger: logx.WithContext(ctx),
		expander: svcCtx.Expander,    // 手动代码
	}
}

func (l *ExpandLogic) Expand(req types.ExpandReq) (*types.ExpandResp, error) {
  // 手动代码开始
	resp, err := expander.NewExpander(l.expander).Expand(l.ctx, &expander.ExpandReq{
		Key: req.Key,
	})
	if err != nil {
		return nil, err
	}

	return &types.ExpandResp{
		Url: resp.Url,
	}, nil
  // 手动代码结束
}

增加了对expander服务的依赖，并通过调用expander的Expand方法实现短链恢复到url

修改internal/logic/shortenlogic.go，如下：

type ShortenLogic struct {
	ctx context.Context
	logx.Logger
	shortener rpcx.Client             // 手动代码
}

func NewShortenLogic(ctx context.Context, svcCtx *svc.ServiceContext) ShortenLogic {
	return ShortenLogic{
		ctx:    ctx,
		Logger: logx.WithContext(ctx),
		shortener: svcCtx.Shortener,    // 手动代码
	}
}

func (l *ShortenLogic) Shorten(req types.ShortenReq) (*types.ShortenResp, error) {
  // 手动代码开始
	resp, err := shortener.NewShortener(l.shortener).Shorten(l.ctx, &shortener.ShortenReq{
		Url: req.Url,
	})
	if err != nil {
		return nil, err
	}

	return &types.ShortenResp{
		ShortUrl: resp.Key,
	}, nil
  // 手动代码结束
}

增加了对shortener服务的依赖，并通过调用shortener的Shorten方法实现url到短链的变换

至此，API Gateway修改完成，虽然贴的代码多，但是期中修改的是很少的一部分，为了方便理解上下文，我贴了完整代码，接下来处理CRUD+cache

8. 定义数据库表结构，并生成CRUD+cache代码

shorturl下创建rpc/model目录：mkdir -p rpc/model

在rpc/model目录下编写创建shorturl表的sql文件shorturl.sql，如下：

CREATE TABLE `shorturl`
(
  `shorten` varchar(255) NOT NULL COMMENT 'shorten key',
  `url` varchar(255) NOT NULL COMMENT 'original url',
  PRIMARY KEY(`shorten`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

创建DB和table

create database gozero;

source shorturl.sql;

在rpc/model目录下执行如下命令生成CRUD+cache代码，-c表示使用redis cache

goctl model mysql ddl -c -src shorturl.sql -dir .

也可以用datasource命令代替ddl来指定数据库链接直接从schema生成

生成后的文件结构如下：

rpc/model
├── shorturl.sql
├── shorturlmodel.go              // CRUD+cache代码
└── vars.go                       // 定义常量和变量

9. 修改shorten/expand rpc代码调用crud+cache代码

修改rpc/expand/etc/expand.yaml，增加如下内容：
```
DataSource: root:@tcp(localhost:3306)/gozero
Table: shorturl
Cache:
  - Host: localhost:6379
```
可以使用多个redis作为cache，支持redis单点或者redis集群

修改rpc/expand/internal/config.go，如下：

type Config struct {
	rpcx.RpcServerConf
	DataSource string             // 手动代码
	Table      string             // 手动代码
	Cache      cache.CacheConf    // 手动代码
}

增加了mysql和redis cache配置

修改rpc/expand/internal/svc/servicecontext.go，如下：

type ServiceContext struct {
	c     config.Config
	Model *model.ShorturlModel   // 手动代码
}

func NewServiceContext(c config.Config) *ServiceContext {
	return &ServiceContext{
		c:     c,
		Model: model.NewShorturlModel(sqlx.NewMysql(c.DataSource), c.Cache, c.Table), // 手动代码
	}
}

修改rpc/expand/internal/logic/expandlogic.go，如下：

type ExpandLogic struct {
	ctx context.Context
	logx.Logger
	model *model.ShorturlModel          // 手动代码
}

func NewExpandLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ExpandLogic {
	return &ExpandLogic{
		ctx:    ctx,
		Logger: logx.WithContext(ctx),
		model:  svcCtx.Model,             // 手动代码
	}
}

func (l *ExpandLogic) Expand(in *expand.ExpandReq) (*expand.ExpandResp, error) {
  // 手动代码开始
	res, err := l.model.FindOne(in.Key)
	if err != nil {
		return nil, err
	}

	return &expand.ExpandResp{
		Url: res.Url,
	}, nil
  // 手动代码结束
}

修改rpc/shorten/etc/shorten.yaml，增加如下内容：
```
DataSource: root:@tcp(localhost:3306)/gozero
Table: shorturl
Cache:
  - Host: localhost:6379
```
可以使用多个redis作为cache，支持redis单点或者redis集群

修改rpc/shorten/internal/config.go，如下：

type Config struct {
	rpcx.RpcServerConf
	DataSource string            // 手动代码
	Table      string            // 手动代码
	Cache      cache.CacheConf   // 手动代码
}

增加了mysql和redis cache配置

修改rpc/shorten/internal/svc/servicecontext.go，如下：

type ServiceContext struct {
	c     config.Config
	Model *model.ShorturlModel   // 手动代码
}

func NewServiceContext(c config.Config) *ServiceContext {
	return &ServiceContext{
		c:     c,
		Model: model.NewShorturlModel(sqlx.NewMysql(c.DataSource), c.Cache, c.Table), // 手动代码
	}
}

修改rpc/shorten/internal/logic/shortenlogic.go，如下：

const keyLen = 6

type ShortenLogic struct {
	ctx context.Context
	logx.Logger
	model *model.ShorturlModel          // 手动代码
}

func NewShortenLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShortenLogic {
	return &ShortenLogic{
		ctx:    ctx,
		Logger: logx.WithContext(ctx),
		model:  svcCtx.Model,             // 手动代码
	}
}

func (l *ShortenLogic) Shorten(in *shorten.ShortenReq) (*shorten.ShortenResp, error) {
  // 手动代码开始，生成短链接
	key := hash.Md5Hex([]byte(in.Url))[:keyLen]
	_, err := l.model.Insert(model.Shorturl{
		Shorten: key,
		Url:     in.Url,
	})
	if err != nil {
		return nil, err
	}

	return &shorten.ShortenResp{
		Key: key,
	}, nil
  // 手动代码结束
}

至此代码修改完成，凡事手动修改的代码我加了标注

10. 完整调用演示

shorten api调用

curl -i "http://localhost:8888/shorten?url=http://www.xiaoheiban.cn"

返回如下：

HTTP/1.1 200 OK
Content-Type: application/json
Date: Sat, 29 Aug 2020 10:49:49 GMT
Content-Length: 21

{"shortUrl":"f35b2a"}

expand api调用

curl -i "http://localhost:8888/expand?key=f35b2a"

返回如下：

HTTP/1.1 200 OK
Content-Type: application/json
Date: Sat, 29 Aug 2020 10:51:53 GMT
Content-Length: 34

{"url":"http://www.xiaoheiban.cn"}

11. Benchmark

因为写入依赖于mysql的写入速度，就相当于压mysql了，所以压测只测试了expand接口，相当于从mysql里读取并利用缓存，shorten.lua里随机从db里获取了100个热key来生成压测请求

可以看出在我的MacBook Pro上能达到3万+的qps。

12. 总结

我们一直强调工具大于约定和文档。

go-zero不只是一个框架，更是一个建立在框架+工具基础上的，简化和规范了整个微服务构建的技术体系。

我们在保持简单的同时也尽可能把微服务治理的复杂度封装到了框架内部，极大的降低了开发人员的心智负担，使得业务开发得以快速推进。

通过go-zero+goctl生成的代码，包含了微服务治理的各种组件，包括：并发控制、自适应熔断、自适应降载、自动缓存控制等，可以轻松部署以承载巨大访问量。

13. 微信交流群

微信关注我们

原文链接：https://my.oschina.net/u/1179539/blog/4536192

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

AB测试-创建一个AB测试

Target：使用该AB测试，您预计能够在下面列举的方面得到提升对AB测试的流程进行管理，能够直观看到在新建，待评审，就绪，运行中，已结束的各个任务。对目前公司各个项目的AB测试有个全局的认识可视化单个AB测试的生命周期，用户可以预先安排上线的实际，结束的实际，系统会对事件情况调整实际的上线时间和结束时间，这一切都可见自动进行显著性分析。根据预算的核心指标进行自动计算A/B测试各组结论的显著性。自动生成数据大盘报表，方便跟踪AB测试的数据情况。系统会根据创建试验时预设的指标，自动生成数据大盘主动反馈，快速反馈。每日会根据现有的数据表现，生成AB测试日报推送到给业务方。另外在AB测试每次改动都会主动推送告知业务方 Blocks: 整个AB测试能够成功落地，还是依赖无觅近一年半以来平台、数仓以及中台的建设，所提供各种各样的脚手架/系统，整个关系如下图：实时用户画像系统：提供了可供进行任意标签组合的用户群。作为AB测试实验的基础埋点地图和埋点管理：提供针对具体AB测试需求的可视化埋点，保证埋点定义的唯一，准确，避免漏埋，错埋维度管理系统和指标管理系统集合实时数仓：能够根据预...

2020-08-28

750

在上一篇文章中，我为大家介绍了《5种创建文件并写入文件数据的方法》，本节我们为大家来介绍6种从文件中读取数据的方法. 另外为了方便大家理解，我为这一篇文章录制了对应的视频：总结java从文件中读取数据的6种方法-JAVA IO基础总结第二篇 Scanner(Java 1.5) 按行读数据及String、Int类型等按分隔符读数据。 Files.lines, 返回Stream(Java 8) 流式数据处理，按行读取 Files.readAllLines, 返回List<String>(Java 8) Files.readString, 读取String(Java 11), 文件最大 2G. Files.readAllBytes, 读取byte[](Java 7), 文件最大 2G. BufferedReader, 经典方式 (Java 1.1 -> forever) 可以说，每一种方法都有自己的适用场景，下文中为大家来一一介绍。如果您看完我的创作，觉得您有帮助的话，请帮忙点赞，您的支持是我不竭的创作动力！ 1.Scanner 第一种方式是Scanner，从JDK1.5...

2020-08-31

721

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。