You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@dubbo.apache.org by il...@apache.org on 2021/01/12 06:02:10 UTC

[dubbo-website] branch master updated: dubbo-go blog, batch 3

This is an automated email from the ASF dual-hosted git repository.

iluo pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/dubbo-website.git


The following commit(s) were added to refs/heads/master by this push:
     new 11ed5a7  dubbo-go blog, batch 3
11ed5a7 is described below

commit 11ed5a7c01da499ef224330476fb5d63a1834309
Author: Ian Luo <ia...@gmail.com>
AuthorDate: Tue Jan 12 14:01:28 2021 +0800

    dubbo-go blog, batch 3
---
 .../zh/blog/news/dubbo-go-hessian2-optimization.md | 244 +++++++++++++++++
 content/zh/blog/news/dubbo-go-router.md            | 294 +++++++++++++++++++++
 content/zh/blog/releases/dubbo-go-1.4.md           | 152 +++++++++++
 static/imgs/blog/dubbo-go/1.4/acl.png              | Bin 0 -> 61310 bytes
 static/imgs/blog/dubbo-go/1.4/config-center.png    | Bin 0 -> 26009 bytes
 static/imgs/blog/dubbo-go/1.4/context.png          | Bin 0 -> 4942 bytes
 static/imgs/blog/dubbo-go/1.4/k8s.png              | Bin 0 -> 93011 bytes
 static/imgs/blog/dubbo-go/1.4/rest.png             | Bin 0 -> 34214 bytes
 static/imgs/blog/dubbo-go/dubbo-go-arch-2.png      | Bin 0 -> 215602 bytes
 static/imgs/blog/dubbo-go/hessian/p1.png           | Bin 0 -> 106511 bytes
 static/imgs/blog/dubbo-go/hessian/p2.png           | Bin 0 -> 107399 bytes
 static/imgs/blog/dubbo-go/hessian/p3.png           | Bin 0 -> 68234 bytes
 static/imgs/blog/dubbo-go/hessian/p4.png           | Bin 0 -> 49751 bytes
 static/imgs/blog/dubbo-go/hessian/p5.png           | Bin 0 -> 59008 bytes
 static/imgs/blog/dubbo-go/hessian/p6.png           | Bin 0 -> 43664 bytes
 static/imgs/blog/dubbo-go/hessian/p7.png           | Bin 0 -> 108335 bytes
 static/imgs/blog/dubbo-go/hessian/p8.png           | Bin 0 -> 74500 bytes
 static/imgs/blog/dubbo-go/router/dubbo-admin-1.png | Bin 0 -> 73321 bytes
 static/imgs/blog/dubbo-go/router/dubbo-admin-2.png | Bin 0 -> 85105 bytes
 static/imgs/blog/dubbo-go/router/router-design.png | Bin 0 -> 39519 bytes
 20 files changed, 690 insertions(+)

diff --git a/content/zh/blog/news/dubbo-go-hessian2-optimization.md b/content/zh/blog/news/dubbo-go-hessian2-optimization.md
new file mode 100644
index 0000000..e9f4f9b
--- /dev/null
+++ b/content/zh/blog/news/dubbo-go-hessian2-optimization.md
@@ -0,0 +1,244 @@
+---
+title: "记一次对 dubbo-go-hessian2 的性能优化"
+linkTitle: "记一次对 dubbo-go-hessian2 的性能优化"
+date: 2021-01-12
+description: >
+    本文介绍了在 dubbo-go-hessian2 中的一次性能调优
+---
+
+
+> dubbo-go-hessian2 是一个用 Go 实现的 hessian 协议 v2.0 版本的序列化库。从项目名称里可以看到主要用在 dubbo-go 这个项目里。hessian 协议作为 dubbo 的默认协议,因此对性能有比较高的要求。
+
+## 立项
+
+譬如有网文 基于Go的马蜂窝旅游网分布式IM系统技术实践 把 dubbo-go 与其他 RPC 框架对比如下:
+
+1. Go STDPRC: Go 标准库的 RPC,性能最优,但是没有治理;
+2. RPCX: 性能优势 2*GRPC + 服务治理;
+3. GRPC: 跨语言,但性能没有 RPCX 好;
+4. TarsGo: 跨语言,性能 5*GRPC,缺点是框架较大,整合起来费劲;
+5. Dubbo-Go: 性能稍逊一筹,比较适合 Go 和 Java 间通信场景使用
+
+有鉴于此,社区便开始组织部分人力,启动了对 dubbo-go 性能优化【同时也欢迎上文作者到钉钉群 23331795 与我们社区交流】。考察 dubbo-go 的各个组件,大家不约而同地决定首先优化比较独立的 dubbo-go-hessian2。
+
+## 起步
+
+在最开始的时候,并没有太想清楚需要做什么,改哪个地方,要优化到何种程度,所以最简单的办法就是看看现状。
+
+首先,写了一个简单的例子,把常见的类型到一个结构体里,然后测一下耗时。
+
+```go
+type Mix struct {
+    A  int
+    B  string
+    CA time.Time
+    CB int64
+    CC string
+    CD []float64
+    D  map[string]interface{}
+}
+
+m := Mix{A: int('a'), B: `hello`}
+m.CD = []float64{1, 2, 3}
+// 再加一层,使得数据显得复杂一些
+m.D = map[string]interface{}{`floats`: m.CD, `A`: m.A, `m`: m}
+```
+
+> 看起来这个结构体跟真实环境里可能不太一样,但是用来分析瓶颈应该是足够了。
+
+然后直接靠 Go Test 写个测试用例:
+
+```go
+func BenchmarkEncode(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        _, _ = encodeTarget(&m)
+    }
+}
+
+func BenchmarkDecode(b *testing.B) {
+    for i := 0; i < b.N; i++ {
+        _, _ = NewDecoder(bytes).Decode()
+    }
+}
+```
+
+> go test -benchmem -run=^$ github.com/apache/dubbo-go-hessian2 -bench "^B" -vet=off -v
+
+得到下面结果:
+
+```
+BenchmarkEncode-8 89461    11485 ns/op    3168 B/op 122 allocs/op
+BenchmarkDecode-8 64914    19595 ns/op    7448 B/op 224 allocs/op
+```
+
+***注:基于 MacBook Pro 2018【主频 Intel Core i7 2.6 GHz】测试。\***
+
+不与同类库作横向比较,仅仅从这个测试结果里的数字上无法得出任何结论。对我们来说更重要的是:它到底慢在哪里。首先想到的手段便是:借助 pprof 生成火焰图,定位 CPU 消耗。
+
+pprof 工具的用法可以参考官网文档。本文测试时直接使用了 Goland 内置 `CPU Profiler` 的测试工具:测试函数左边的 `Run xx with 'CPU Profiler'`。
+
+![](/imgs/blog/dubbo-go/hessian/p2.png)
+
+测试跑完后, Goland 直接显示火焰图如下:
+
+![](/imgs/blog/dubbo-go/hessian/p3.png)
+
+从这个图里可以看到,测试代码大概占用了左边的70%,右边30%是运行时的一些消耗,运行时部分一般包括 gc、schedule 两大块,一般不能直接优化。图上左边可以清晰地看到 `encObject` 里 `RegisterPOJO` 和 `Encode` 各占了小一半。
+
+完成序列化功能的 `Encode` 消耗 CPU 如此之多尚可理解,而直觉上,把类对象进行解析和注册 `RegisterPOJO` 是不应该成为消耗大户的。所以猜测这个地方要么注册有问题,要么有重复注册。
+
+下一步分析,用了一个简单的办法:在这个函数里加日志。然后继续再跑一下 benchmark,可以看到性能瓶颈处:容器读写的地方。
+
+既然知道这里做了许多重复的无用功,就很容易明确优化方法:加缓存。把已经解析过的结果缓存下来,下次需要的时候直接取出使用。改进后的代码简单如下:
+
+```go
+if goName, ok := pojoRegistry.j2g[o.JavaClassName()]; ok {
+    return pojoRegistry.registry[goName].index
+}
+```
+
+这里刚开始有个疑问,为什么要分两步先取 `JavaClassName` 再取 `GoName` 而不直接取后者?看起来好像是多此一举了,但其实 `JavaClassName` 是类直接定义的,而 `GoName` 却依赖一次反射。相较之下两次转换的消耗可以忽略了。改完之后再跑一下 benchmark:
+
+```
+BenchmarkEncode-8 197593   5601 ns/op   1771 B/op   51 allocs/op
+```
+
+非常惊讶地看到,吞吐量大概是原来的 200%。与上面的火焰图对比,可以粗略的计算,`RegiserPOJO` 大概占了整体的30%,改进后应该也只有原来的 `1 / 0.7 * 100% = 140%` 才对。答案也可以在火焰图里找到:
+
+![](/imgs/blog/dubbo-go/hessian/p4.png)
+
+除了 `RegisterPOJO` 被干掉以外,与上图对比,还有哪些区别呢?可以看到,原来占用将近 20% 的 `GC` 也几乎看不到了。所以真实的 CPU 利用率也要加上这部分的增长,大约 `1 / 0.5 * 100% = 200%`。
+
+> 需要提醒的是,benchmark 跑出来的结果并不算稳定,所以你自己压出来的结果跟我的可能不太一致,甚至多跑几次的结果也不完全一样。对于上面的数字你只要理解原因就好,上下浮动10%也都是正常范围。
+>
+> 反过来看,这也算是 GC 优化的一个角度。碰到 GC 占用CPU过高,除了去一个个换对象池,也可以重点看看那些被频繁调用的模块。当然更科学的方法是看 `pprof heap` / `memory profiler` 。
+
+针对这个结果,可以看到 `encObject` 以上都被切割成了不同的小格子,不再有像 `RegisterPOJO` 那样的大块占用,一般情况下,优化到这里就可以了。
+
+看完了 `Encode` ,再来看看 `Decode` ,方法类似,直接看 Goland 生成的火焰图:
+
+![](/imgs/blog/dubbo-go/hessian/p5.png)
+
+这个图有点迷惑性,好像也被分成差不多的小格子了。可以点开 `decObject` 这一层:
+
+![](/imgs/blog/dubbo-go/hessian/p6.png)
+
+这个时候原来小的 `...` 会显示具体内容,需要注意的是里面有两个 `findField` ,在复杂的调用里经常会遇到这种情况:一个耗资源的函数被分到了许多函数里,导致在看火焰图时并不能直观地看到它就是瓶颈。比较常见的有序列化、日志、网络请求等每个模块都会干一点却又没有一个全局的函数只干他一件事。这个时候除了肉眼去找以外也可以借助于另外一个工具:
+
+![](/imgs/blog/dubbo-go/hessian/p7.png)
+
+在这个 `Method List` 里可以明显看到 `findField` 已经被合并到一起了,总占用接近 CPU 的一半,看到这里你大概就知道它应该是个优化点了。
+
+## 进一步
+
+函数 `func findField(name string, typ reflect.Type) ([]int, error)` 的作用是在一个类型里寻找指定属性的位置(Index,反射包里用它来表示是第几个字段)。很容易想到,对于一个结构体来说,每个字段的位置从一开始就确定了,所以用缓存一样可以解决这个问题。一个简单的优化如下:
+
+```go
+func findField(name string, typ reflect.Type) (indexes []int, err error) {
+    typCache, _ := findFieldCache.LoadOrStore(typ, &sync.Map{})
+    indexes, _ := typCache.(*sync.Map).Load(name)
+    if len(indexes.([]int)) == 0 {
+        err = perrors.Errorf("failed to find field %s", name)
+    }
+
+    return indexes.([]int), err
+
+    // ...
+}
+```
+
+```
+- BenchmarkDecode-8 57723    17987 ns/op    7448 B/op    224 allocs/op
++ BenchmarkDecode-8 82995    12272 ns/op    7224 B/op    126 allocs/op
+```
+
+可以看到,结果并不如预期的那样提升一倍效果。这个代码乍看起来,好像除了有一些啰嗦的断言,好像也没别的东西了,为什么只有60%的提升呢,我们还是借助下工具
+
+![](/imgs/blog/dubbo-go/hessian/p8.png)
+
+可以看到:读缓存耗费了 7% 的资源。其中,`sync.(*Map)` 不便优化,但 `newobejct` 是哪里来的呢?代码里可以看到,唯一定义新对象的地方就是函数第一行的 `&sync.Map` ,我抱着试一试的心态把 `LoadOrStore` 拆成了两步
+
+```go
+typCache, ok := findFieldCache.Load(typ)
+if !ok {
+    typCache = &sync.Map{}
+    findFieldCache.Store(typ, typCache)
+}
+```
+
+```
+- BenchmarkDecode-8          82995         12272 ns/op        7224 B/op         126 allocs/op
++BenchmarkDecode-8         103876         12385 ns/op        6568 B/op         112 allocs/op
+```
+
+看结果,着实出乎意料。想起来以前看 Java 代码时经常碰到这样的代码:
+
+```go
+if ( logLevel >= `info` ) {
+    log.Info(...)
+}
+```
+
+以前一直觉得这个 `if` 真是浪费感情,现在想来,别是一番认知了。如果能提供一个 `LoadOrStore(key, func() interface{})` 的方法, 会不会更好一些?
+
+到这里的话,我们做了两个比较大的优化,整体性能大约提升了一倍。如果仔细看火焰图,还会发现有很多小的优化点,但是由于没有什么特别质的飞跃,这里不再赘述。有兴趣的小伙伴可以到 PR Imp: cache in reflection 里阅读相关的讨论。
+
+## 更进一步
+
+优化到此,依然藏着一个更深层次的问题:找一个可靠的参考基准,以衡量目前的工作结果【毕竟没有对比就没有伤害】。一个很容易想到的比较对象是 Go 语言官方的 `json` 标准库。
+
+把 dubbo-go-hessian2 与 `json` 标准库做比较如下:
+
+```bash
+$ go test -benchmem -run=^$ github.com/apache/dubbo-go-hessian2 -bench "^B" -vet=off -v -count=5
+goos: darwin
+goarch: amd64
+pkg: github.com/apache/dubbo-go-hessian2
+BenchmarkJsonEncode
+BenchmarkJsonEncode-8  249114    4719 ns/op    832 B/op  15 allocs/op
+BenchmarkJsonEncode-8  252224    4862 ns/op    832 B/op  15 allocs/op
+BenchmarkJsonEncode-8  240582    4739 ns/op    832 B/op  15 allocs/op
+BenchmarkJsonEncode-8  213283    4784 ns/op    832 B/op  15 allocs/op
+BenchmarkJsonEncode-8  227101    4665 ns/op    832 B/op  15 allocs/op
+BenchmarkEncode
+BenchmarkEncode-8  182184    5615 ns/op    1771 B/op  51 allocs/op
+BenchmarkEncode-8  183007    5565 ns/op    1771 B/op  51 allocs/op
+BenchmarkEncode-8  218664    5593 ns/op    1771 B/op  51 allocs/op
+BenchmarkEncode-8  214704    5886 ns/op    1770 B/op  51 allocs/op
+BenchmarkEncode-8  181861    5605 ns/op    1770 B/op  51 allocs/op
+BenchmarkJsonDecode
+BenchmarkJsonDecode-8 123667    8412 ns/op    1776 B/op  51 allocs/op
+BenchmarkJsonDecode-8 122796    8497 ns/op    1776 B/op  51 allocs/op
+BenchmarkJsonDecode-8 132103    8471 ns/op    1776 B/op  51 allocs/op
+BenchmarkJsonDecode-8 130687    8492 ns/op    1776 B/op  51 allocs/op
+BenchmarkJsonDecode-8 127668    8476 ns/op    1776 B/op  51 allocs/op
+BenchmarkDecode
+BenchmarkDecode-8 107775    10092 ns/op     6424 B/op    98 allocs/op
+BenchmarkDecode-8 110996    9950 ns/op     6424 B/op    98 allocs/op
+BenchmarkDecode-8 111036    10760 ns/op     6424 B/op    98 allocs/op
+BenchmarkDecode-8 113151    10063 ns/op     6424 B/op    98 allocs/op
+BenchmarkDecode-8 109197    10002 ns/op     6424 B/op    98 allocs/op
+PASS
+ok      github.com/apache/dubbo-go-hessian2    28.680s
+```
+
+虽然每次的结果不稳定,但就整体而言,目前的序列化和反序列化性能大概都是JSON标准库的85%左右。这个成绩并不能说好,但短期内能花20分的精力得到一个80分的结果,应该也是可以接受的。至于剩下的20%,就不是靠改几行代码就能搞定了。内存分配是否合理、执行流程是否有冗余,都是需要一点一滴地去改进。
+
+## 总结
+
+最后,我们来总结一下本文主要的优化步骤:
+
+- 利用火焰图 快速定位消耗 CPU 较高的模块;
+- 利用缓存机制,快速消除重复的计算;
+- 利用 CallTree、MethodList 等多种工具分析小段代码的精确消耗;
+- 遵循二八定律,以最小的成本做出一个效果显著的收益。
+
+### 欢迎加入 dubbo-go 社区
+
+目前 dubbo-go 已经到了一个比较稳定成熟的状态。在接下来的版本里面,我们将集中精力在云原生上。下一个版本,我们将首先实现应用维度的服务注册,这是一个和现有注册模型完全不同的新的注册模型。也是我们朝着云原生努力的一个关键版本。
+
+dubbo-go 钉钉群 **23331795** 欢迎你的加入。
+
+#### 作者信息
+
+张慧仁,github id: micln,任职 得到APP 后端开发。
\ No newline at end of file
diff --git a/content/zh/blog/news/dubbo-go-router.md b/content/zh/blog/news/dubbo-go-router.md
new file mode 100644
index 0000000..08beeb2
--- /dev/null
+++ b/content/zh/blog/news/dubbo-go-router.md
@@ -0,0 +1,294 @@
+---
+title: "dubbo-go 中如何实现路由规则功能"
+linkTitle: "dubbo-go 中如何实现路由规则功能"
+date: 2021-01-12
+description: >
+    本文介绍了在 dubbo-go 中路由规则功能的设计与实现
+---
+
+
+## Let‘s Go!
+
+最近在 Apache/dubbo-go(以下简称 dubbo-go )社区中,路由规则突然成了呼声最高的功能之一。那到底为什么需要路由规则?
+
+先路由规则需要实现的功能:
+
+路由规则( routing rule )是为了改变网络流量所经过的途径而修改路由信息的技术,主要通过改变路由属性(包括可达性)来实现。在发起一次 RPC 调用前起到过滤目标服务器地址的作用,过滤后的地址列表,将作为消费端最终发起 RPC 调用的备选地址。
+
+试想该下场景:使用 dubbo-go 在生产环境上,排除预发布机。使用路由规则实现不是很合适吗?
+
+虽然知道了路由规则需要实现什么功能,但还不足以实现一个完整的路由规则功能。除此之外,还需要知道如何方便的管理路由规则。
+
+## 目标
+
+综上所述,可以总结出以下 **目标**
+
+- 支持方便扩展路由规则的配置;
+- 可以方便的管理路由规则配置,如支持本地与远程配置中心管理;
+- 与 Dubbo 现有的配置中心内的路由规则配置文件兼容,降低在新增语言栈的学习及使用成本;
+
+## 路由规则设计
+
+在设计之初,首先要考虑的是路由规则应该放在整个服务治理周期的哪个阶段呢?
+
+有些读者可能会有点困惑,我连架构图都不知道,如何考虑在哪个阶段?不怕,下图马上给你解惑。
+
+![](/imgs/blog/dubbo-go/dubbo-go-arch-2.png)
+
+可以看到图中的 Router 就是路由规则插入的位置,目前路由规则主要用于控制 Consumer 到 Provider 之间的网络流量的路由路径。
+
+除此之外,还有几个问题是需要优先考虑:
+
+1.需要什么功能?
+
+- 通过配置信息生成路由规则,包括:读取并解析本地配置文件,读取并解析配置中心的配置。以责任链模式串联起来。
+- 通过路由规则,匹配本地信息与远端服务信息,过滤出可以调用的远端节点,再进行负载均衡。
+
+2.如何设计接口?
+
+通过第一点,我们能设计出以下接口来实现所需的功能。
+
+- 路由规则接口:用于路由规则过滤出可以调用的远端节点。
+- 路由规则责任链接口:允许执行多个路由规则。
+- 配置信息生成路由规则接口:解析内部配置信息(common.URL)生成对应的路由规则。
+- 配置文件生成路由规则接口:解析配置文件生成对应的路由规则。
+
+3.如何实现本地与远程路由规则配置加载?
+
+- 本地路由规则配置:在原配置加载阶段,新增读取路由配置文件。使用 `FIleRouterFactory` 解析后,生成对应路由规则,放置到内存中备用。
+- 远程路由规则配置:在 zookeeper 注册并监听静态资源目录后。读取静态资源,筛选符合路由规则配置信息,通过 `RouterFactory` 生成对应路由规则,放置到内存中备用。
+
+### Router
+
+匹配及过滤远程实例的路由规则。 
+
+```golang
+// Router
+type Router interface {
+	// Route determine the target invoker list.
+	Route([]protocol.Invoker, *common.URL, protocol.Invocation) []protocol.Invoker
+	// Priority return priority in router
+	// 0 to ^int(0) is better
+	Priority() int64
+	// URL return URL in router
+	URL() common.URL
+}
+```
+
+目前已有实现类包括:
+
+- listenableRouter
+- AppRouter
+- ConditionRouter
+- HealthCheckRouter
+- FileConditionRouter
+
+### RouterChain
+
+执行多个路由规则的责任链。 
+
+```golang
+// Chain
+type Chain interface {
+	// Route determine the target invokers list with chain.
+	Route([]protocol.Invoker, *common.URL, protocol.Invocation) []protocol.Invoker
+	// AddRouters add routers
+	AddRouters([]Router)
+}
+```
+
+### FIleRouterFactory
+
+生成解析配置文件生成路由规则的工厂类。 
+
+```golang
+// RouterFactory router creates factory use for parse config file
+type FileRouterFactory interface {
+	// NewFileRouter create file router with config file
+	NewFileRouter([]byte) (Router, error)
+}
+```
+
+### RouterFactory
+
+通过配置信息生成路由规则的工厂类。 
+
+```golang
+// RouterFactory router create factory
+type RouterFactory interface {
+	// NewRouter creates router instance with URL
+	NewRouter(*common.URL) (Router, error)
+}
+```
+
+## 实现
+
+![](/imgs/blog/dubbo-go/router/router-design.png)
+
+实现路由规则以兼容 dubbo 为首要目标,降低使用者的学习成本为辅助目标。与配置中心模块相结合,实现路由规则远程统一管理与下发。
+
+### 规则类型
+
+下面先来介绍一下有哪些具体的路由规则实现。
+
+#### 条件路由
+
+dubbo-go 中第一个支持的路由规则,允许用户通过配置文件及配置中心管理路由规则。
+
+与之相似的一个概念是 dubbo-go 里面的 group 概念,但是条件路由提供了更加细粒度的控制手段和更加丰富的表达语义。比较典型的使用场景是黑白名单设置,灰度以及测试等。
+
+#### 健康检查路由
+
+在 RPC 调用中,我们希望尽可能地将请求命中到那些处理能力快、处于健康状态的实例,该路由的功能就是通过某种策略断定某个实例不健康,并将其排除在候选调用列表,优先调用那些健康的实例。这里的”健康”可以是我们自己定义的状态,默认实现即当错误比例到达某一个阈值时或者请求活跃数大于上限则认为其不健康,允许用户扩展健康检测策略。
+
+在我们服务治理里面,核心的问题其实就在于如何判断一个实例是否可用。无论是负载均衡、
+
+熔断还是限流,都是对这个问题的解答。所以,这个 feature 是一个很好的尝试。因为我们接下来计划提供的特性,基于规则的限流以及动态限流,都是要解决 “如何断定一个实例是否可用” 这么一个问题。
+
+所以欢迎大家使用这个特性,并向社区反馈各自设定的健康指标。这对我们接下来的工作会有很大的帮助。
+
+#### 标签路由
+
+以 Provider 为维度,通过将某一个或多个服务的提供者划分到同一个分组,约束流量只在指定分组中流转,从而实现流量隔离的目的,可以作为蓝绿发布、灰度发布等场景的能力基础。
+
+- 静态打标:根据配置文件所配置的标签,固定给 Provider 设置标签。
+- 动态打标:基于健康检查路由,根据服务不同时刻,不同状态,动态在 Provider 设置适合的标签。
+
+### 分析
+
+接着,以条件路由在 zookeeper 实现为例,对服务提供者与服务消费者进行整体流程分析。
+
+#### 如何配置条件路由规则
+
+配置条件路由规则既可以通过本地配置文件也能通过远程配置中心进行配置,配置生效流程都是:配置文件 => dubbo 内部协议 => 缓存至应用级内存 => 过滤出可调用节点。
+
+**dubbo-admin** 【服务治理/条件路由】增加路由规则配置,zookeeper 中会自动生成其对应配置节点,内容均为 **dubbo-admin** 中设置的配置。
+
+**全局配置**
+
+对应应用级全局路由规则配置。
+
+```
+/dubbo/config/dubbo/user-info-server(应用名).condition-router
+```
+
+应用名:只对 user-info-server 应用生效 .condition-router: 路由类型。除此之外,还有 .tag-router 表示标签路由。
+
+**服务配置**
+
+对应服务级所有路由规则配置。
+
+```
+/dubbo/ com.ikurento.user.UserProvider(服务名) /routers
+```
+
+服务名:只对 com.ikurento.user.UserProvider 服务生效。
+
+### 实现 Router
+
+```golang
+func (c *ConditionRouter) Route(invokers []protocol.Invoker, url *common.URL, invocation protocol.Invocation) []protocol.Invoker {
+	if !c.Enabled() {
+		return invokers
+	}
+	if len(invokers) == 0 {
+		return invokers
+	}
+	isMatchWhen := c.MatchWhen(url, invocation)
+	if !isMatchWhen {
+		return invokers
+	}
+	var result []protocol.Invoker
+	if len(c.ThenCondition) == 0 {
+		return result
+	}
+	for _, invoker := range invokers {
+		invokerUrl := invoker.GetUrl()
+		isMatchThen := c.MatchThen(&invokerUrl, url)
+		if isMatchThen {
+			result = append(result, invoker)
+		}
+	}
+	if len(result) > 0 {
+		return result
+	} else if c.Force {
+		rult, _ := url.GetParamAndDecoded(constant.RULE_KEY)
+		localIP, _ := gxnet.GetLocalIP()
+		logger.Warnf("The route result is empty and force execute. consumer: %s, service: %s, route: %s", localIP, url.Service(), route)
+		return result
+	}
+	return invokers
+}
+```
+
+以下为必须实现的方法,以下方法用于获取过滤服务端节点配置。
+
+- Route: 根据配置,调用节点与被调用节点,过滤出可调用节点。
+- Priority: 路由规则优先级,需要是个正整数。
+- URL: 通过路由规则转换出来的 dubbo 内部协议。
+
+更多实现参考:
+
+路由规则:https://github.com/apache/dubbo-go/tree/master/cluster/router/condition
+
+其中包含监听配置中心实现:https://github.com/apache/dubbo-go/blob/master/cluster/router/condition/listenable_router.go
+
+## 使用方法
+
+经过上面设计与实现的分析,大概也能猜测到如何使用:
+
+```golang
+import (
+	"github.com/apache/dubbo-go/common"
+	"github.com/apache/dubbo-go/protocol"
+	
+	_ "github.com/apache/dubbo-go/config_center/zookeeper"
+	_ "github.com/apache/dubbo-go/cluster/router/condition"
+)
+```
+
+如图所示,使用路由规则并不复杂,只需要把对应的依赖引入进来。在包初始化的时候,会创建出来对应的路由规则的实现。比如说加载条件路由、健康检测路由或者标签作为路由规则:
+
+### 本地路由规则配置
+
+```golang
+_ "github.com/apache/dubbo-go/cluster/router/condition"
+```
+
+仅仅引用依赖包还不直接使用,还需要配置指定的配置文件: ***router_config.yml\*** ,内容如下:
+
+```golang
+# dubbo router yaml configure file
+priority: 1
+force: true
+conditions : ["host = 1.1.1.1 => host = 192.168.199.214"]
+```
+
+更多配置方式:[条件路由配置](http://dubbo.apache.org/zh-cn/docs/user/demos/routing-rule.html)
+
+### 配置中心配置
+
+```golang
+_ "github.com/apache/dubbo-go/config_center/zookeeper"
+```
+
+目前仅支持 zookeeper 配置中心,与 dubbo-admin 结合即可使用。配置方式如下:
+
+![](/imgs/blog/dubbo-go/router/dubbo-admin-1.png)
+
+![](/imgs/blog/dubbo-go/router/dubbo-admin-2.png)
+
+## 总结
+
+更加具体的实现,我就不详细论述,大家可以去看源码,欢迎大家持续关注,或者贡献代码。
+
+整个路由规则功能,已经能跟上 dubbo 2.7.x 版本,已经支持本地及远端路由规则配置管理。从扩展性来说,是比较便利。目前已经支持条件路由、标签路由与健康检测路由,虽然能满足基本使用场景,距离完善还有还长远的路。
+
+未来计划:
+
+1. 更多的配置中心支持,理论上已经支持,但还没测试。
+2. service-router(未支持)
+3. 标签路由-配置中心(未支持)
+4. 目前路由与配置中心结合的代码,对新增路由规则并不友好,有一定接入成本。
+
+欢迎大家关注或者贡献代码,https://github.com/apache/dubbo-go
\ No newline at end of file
diff --git a/content/zh/blog/releases/dubbo-go-1.4.md b/content/zh/blog/releases/dubbo-go-1.4.md
new file mode 100644
index 0000000..5e6714a
--- /dev/null
+++ b/content/zh/blog/releases/dubbo-go-1.4.md
@@ -0,0 +1,152 @@
+---
+title: "dubbo-go 1.4.0"
+linkTitle: "dubbo-go 1.4.0"
+date: 2021-01-12
+description: >
+    dubbo-go 1.4.0 版本发布,支持 K8s 注册中心、rest 协议
+---
+
+得益于社区活跃的支持,2020 年 3 月 25 日 我们发布了一个让人兴奋的版本——dubbo-go v1.4.0。除了继续支持已有的 Dubbo 的一些特性外, dubbo-go 开始了一些自己的创新尝试。
+
+这个版本,最大的意义在于,做了一些支持云原生的准备工作。比如说,社区在探讨了很久的 k8s 落地之后,终于拿出来了使用 k8s 作为注册中心的解决方案。
+
+其次一个比较大的改进是--我们在可观测性上也迈出了重要的一步。在这之前,dubbo-go只提供了日志这么一个单一手段,内部的信息比较不透明,这个版本将有很大的改善。
+
+最后一个令人心动的改进是,我们支持了 REST 协议。
+
+## 1. K8s 注册中心
+
+dubbo-go 注册中心的本质为K/V型的数据存储。当前版本实现了以 Endpoint 为维度在 k8s API Server 进行服务注册和发现的方案【下文简称 Endpoint 方案】,架构图如下。
+
+![](/imgs/blog/dubbo-go/1.4/k8s.png)
+
+Endpoint 方案,首先将每个 dubbo-go 进程自身服务信息序列化后,通过 Kubernetes 提供的 Patch 的接口写入在自身 Pod 对象的 Annotation 中。其次,通过 Kubernetes 的 Watch 接口观察集群中本 Namespace 内带有某些固定lable [见上图] Pod 的Annotation 信息的更新,处理服务健康检查、服务上下线等情况并实时更新本地缓存。整体流程仅使用 Kubernetes 原生 API 完成将 Kubernetes 作为注册中心的功能特性。
+
+这个方案非常简洁,不需要实现额外的第三方模块,也不需要对 Dubbo 业务作出改动,仅仅把 k8s 当做部署平台,依赖其容器管理能力,没有使用其 label selector 和 service 等服务治理特性。如果站在 k8s Operator 的角度来看,Operator 方案的优点即 Endpoint 方案的缺点,Endpoint 方案无法使用 k8s 的健康检查能力,亦没有使用 k8s service 的事件监听能力,每个 consumer 冗余监听一些不必要监听的事件,当 Endpoint 过多时会加大 API Server 的网络压力。
+
+目前 dubbo-go 社区其实已经有了 operator 版本注册中心的技术方案, 后续版本【计划版本是 v1.6】的 dubbo-go 会给出其实现。相比当前实现,operator 方案开发和线上维护成本当然上升很多。二者如同硬币的两面,社区会让两种方式会共存,以满足不同 level 的使用者。
+
+注意: 因 Pod 被调度而 IP 发生变化时,当前版本的 configuration 以及 router config 模块暂时无法动态更新。这有待于我们进一步解决。
+
+参考范例[^1].
+
+## 2. tracing 和 metric
+
+可观测性是微服务重要的一环,也是我们1.4版本着力支持的部分。在1.4版本中,我们主要在 tracing 和 metric 两个方向提供了支持。
+
+为了支持 tracing 和 metric,关键的一点是支持context在整个调用过程中传递。为此我们解决了context跨端传递的问题。目前用户可以在接口中声明 context 并且设置值,dubbo-go 在底层完成 context 内容从 client 传递到 server 的任务。
+
+![](/imgs/blog/dubbo-go/1.4/context.png)
+
+在 metric 方面,dubbo-go 开始支持 Prometheus 采集数据了。目前支持 Prometheus中 的 Histogram 和 Summary。用户也可以通过扩展 Reporter 接口来自定义数据采集。
+
+在 tracing 方面,目前 dubbo-go 的设计是采用 opentracing 作为统一的 API,在该 API 的基础上,通过在 client 和 server 之中传递 context,从而将整个链路串起来。用户可以采用任何支持 opentracing API 的监控框架来作为实现,例如 zipkin,jaeger 等。
+
+## 3. rest协议支持
+
+Dubbo 生态的应用与其他生态的应用互联互通,一直是 dubbo-go 社区追求的目标。dubbo-go v1.3 版本已经实现了 dubbo-go 与 grpc 生态应用的互联互通,若想与其他生态如 Spring 生态互联互通,借助 rest 协议无疑是一个很好的技术手段。
+
+Rest 协议是一个很强大并且社区呼声很高的特性,它能够有效解决 open API,前端通信,异构系统通信等问题。比如,如果你的公司里面有一些陈年代码是通过 http 接口来提供服务的,那么使用我们的 rest 协议就可以无缝集成了。
+
+通过在 dubbo-go 中发布 RESTful 的接口的应用可以调用任意的 RESTful 的接口,也可以被任何客户端以 http 的形式调用,框架图如下:
+
+![](/imgs/blog/dubbo-go/1.4/rest.png)
+
+在设计过程中,考虑到不同的公司内部使用的 web 框架并不相同,所以我们允许用户扩展自己 rest server ( web 框架在 dubbo-go的封装)的实现,当然,与 rest server 相关的,诸如 filter 等,都可以在自己的 rest server 实现内部扩展。
+
+## 4. 路由功能增强
+
+路由规则在发起一次 RPC 调用前起到过滤目标服务器地址的作用,过滤后的地址列表,将作为消费端最终发起 RPC 调用的备选地址。v1.4 版本的 dubbo-go 实现了 Condition Router 和 Health Instance First Router,将在后面版本中陆续给出诸如 Tag Router 等剩余 Router 的实现。
+
+### 4.1 条件路由
+
+条件路由,是 dubbo-go 中第一个支持的路由规则,允许用户通过配置文件及远端配置中心管理路由规则。
+
+与之相似的一个概念是 dubbo-go 里面的 group 概念,但是条件路由提供了更加细粒度的控制手段和更加丰富的表达语义。比较典型的使用场景是黑白名单设置,灰度以及测试等。
+
+参考范例[^2]。
+
+### 4.2 健康实例优先路由
+
+在 RPC 调用中,我们希望尽可能地将请求命中到那些处理能力快、处于健康状态的实例,该路由的功能就是通过某种策略断定某个实例不健康,并将其排除在候选调用列表,优先调用那些健康的实例。这里的"健康"可以是我们自己定义的状态,默认实现即当错误比例到达某一个阈值时或者请求活跃数大于上限则认为其不健康,允许用户扩展健康检测策略。
+
+在我们服务治理里面,核心的问题其实就在于如何判断一个实例是否可用。无论是负载均衡、
+
+熔断还是限流,都是对这个问题的解答。所以,这个 feature 是一个很好的尝试。因为我们接下来计划提供的特性,基于规则的限流以及动态限流,都是要解决“如何断定一个实例是否可用”这么一个问题。
+
+所以欢迎大家使用这个特性,并向社区反馈各自设定的健康指标。这对我们接下来的工作会有很大的帮助。
+
+## 5. hessian 协议增强
+
+相较于 dubbo 的 Java 语言以及其他多语言版本,dubbo-go 社区比较自豪的地方之一就是:无论底层网络引擎还是原生使用的 hessian2 协议,以及整体服务治理框架,都由 dubbo-go 社区从零开发并维护。v1.4 版本的 dubbo-go 对 hessian2 协议又带来了诸多新 feature。
+
+### 5.1 支持 dubbo 协议的 attachments
+
+在 dubbo-go中,attachments 机制用于传递业务参数之外的附加信息,是在客户端和服务端之间传递非业务参数信息的重要方式。
+
+hessian 编码协议将之编码在 body 内容的后面进行传输,dubbo-go-hessian2 之前并不支持读/写 attachments,在多个使用方【如蚂蚁金服】的要求下,dubbo-go-hessian2 以兼容已有的使用方式为前提,支持了 attachments 的读/写。
+
+Request 和 Response 的 struct 中定义了 attachments 的 map,当需要使用 attachments,需要由使用方构造这两种类型的参数或者返回对象。否则,将无法在hessian的传输流中获取和写入attachments。
+
+另外,利用 dubbo-go 调用链中传输 context 的功能,用户已经可以在服务方法中通过 context 添加 attachments了。
+
+### 5.2 支持忽略非注册 pojo 的解析方式
+
+由于 hessian 编码协议与 Java 的类型高度耦合,在 golang 的实现中会相对比较麻烦,需要有指明的对应类型。dubbo-go-hessian2 的实现方式是:定义 POJO 接口,要求实现 JavaClassName 方法来供程序获取 Java 对应的类名。这导致了接收到包含未注册类的请求时,将会无法解析而报错,这个问题以前是无法解决的。
+
+但是,有一些使用场景如网关或者 service mesh 的 sidecar,需要在不关心 Java 类的具体定义的情况下,像 http读取 header 信息一样仅仅读取 dubbo 请求的附加信息,将 dubbo/dubbo-go 请求转发。通过该 feature,网关/sidecar 并不关注请求的具体内容,可以在解析请求的数据流时跳过无法解析的具体类型,直接读取 attachments 的内容。
+
+该实现通过在 Decoder 中添加的 skip 字段,对每一个 object 做出特殊处理。
+
+### 5.3 支持 java.math.BigInteger 和 java.math.BigDecimal
+
+在 Java 服务中,java.math.BigInteger 和 java.math.BigDecimal 是被频繁使用的数字类型,hessian 库将它们映射为 github.com/dubbogo/gost/math/big 下的对应类型。
+
+### 5.4 支持 ‘继承’ 和忽略冗余字段
+
+由于 go 没有继承的概念,所以在之前的版本,Java 父类的字段不被 dubbo-go-hessian2 所支持。新版本中,dubbo-go-hessian2 将Java来自父类的字段用匿名结构体对应,如:
+
+```go
+type Dog struct {
+    Animal
+    Gender  string
+    DogName string `hessian:"-"`
+}
+```
+
+同时,就像 json 编码中通过 `immediately` 可以在序列化中忽略该字段,同理,通过 `hessian:"-"` 用户也可以让冗余字段不参与 hessian 序列化。
+
+目前,上述四个特性已被某 Go 版本的 sidecar 集成到其商业版本中提供商业服务。
+
+## 6. Nacos 配置中心
+
+配置中心是现代微服务架构里面的核心组件,现在 dubbo-go 提供了对配置中心的支持。
+
+![](/imgs/blog/dubbo-go/1.4/config-center.png)
+
+Nacos 作为一个易于构建云原生应用的动态服务发现、配置管理和服务管理平台,在该版本终于作为配置中心而得到了支持。
+
+参考范例[^3].
+
+## 7. 接口级签名认证
+
+Dubbo 鉴权认证是为了避免敏感接口被匿名用户调用而在 SDK 层面提供的额外保障。用户可以在接口级别进行定义是否允许匿名调用,并对调用方进行验签操作,对于验签不通过的消费端,禁止调用。
+
+![](/imgs/blog/dubbo-go/1.4/acl.png)
+
+如上图,总体实现基于 AK/SK 机制,应用通过 HTTPS 通信,启动时向鉴权服务拉取,定期更新。且允许用户自定义获取 AK/SK 的源,在 RPC 层面保障安全性。
+
+## 8. 回顾与展望
+
+目前 dubbo-go 已经到了一个比较稳定成熟的状态。在接下来的版本里面,我们将集中精力在云原生上。下一个版本,我们将首先实现应用维度的服务注册,这是一个和现有注册模型完全不同的新的注册模型。也是我们朝着云原生努力的一个关键版本。
+
+在可观测性上,我们计划在整个 dubbo-go 的框架内,引入更多的埋点,收集更加多的内部状态。这需要实际生产环境用户的使用反馈,从而知道该如何埋点,收集何种数据。
+
+在限流和熔断上,可以进一步扩展。当下的限流算法,是一种静态的算法--限流参数并没有实时根据当前服务器的状态来推断是否应该限流,它可能仅仅是用户的经验值。其缺点在于,用户难以把握应该如何配置,例如 TPS 究竟应该设置在多大。所以计划引入一种基于规则的限流和熔断。这种基于规则的限流和熔断,将允许用户设置一些系统状态的状态,如 CPU 使用率,磁盘 IO,网络 IO 等。当系统状态符合用户规则时,将触发熔断。
+
+目前这些规划的 任务清单[^4],都已经放入在 dubbo-go 项目的 issue 里面,欢迎感兴趣的朋友认领参与开发。dubbo-go 社区在 **钉钉群 23331795** 欢迎你的加入。
+
+[^1]: https://github.com/apache/dubbo-samples/tree/master/golang/registry/kubernetes
+[^2]: https://github.com/dubbogo/dubbo-samples/tree/master/golang/router/condition
+[^3]: https://github.com/dubbogo/dubbo-samples/tree/master/golang/configcenter/nacos
+[^4]: https://github.com/apache/dubbo-go/milestone/1
\ No newline at end of file
diff --git a/static/imgs/blog/dubbo-go/1.4/acl.png b/static/imgs/blog/dubbo-go/1.4/acl.png
new file mode 100644
index 0000000..679e90a
Binary files /dev/null and b/static/imgs/blog/dubbo-go/1.4/acl.png differ
diff --git a/static/imgs/blog/dubbo-go/1.4/config-center.png b/static/imgs/blog/dubbo-go/1.4/config-center.png
new file mode 100644
index 0000000..5fe471a
Binary files /dev/null and b/static/imgs/blog/dubbo-go/1.4/config-center.png differ
diff --git a/static/imgs/blog/dubbo-go/1.4/context.png b/static/imgs/blog/dubbo-go/1.4/context.png
new file mode 100644
index 0000000..a491cbb
Binary files /dev/null and b/static/imgs/blog/dubbo-go/1.4/context.png differ
diff --git a/static/imgs/blog/dubbo-go/1.4/k8s.png b/static/imgs/blog/dubbo-go/1.4/k8s.png
new file mode 100644
index 0000000..97f3caa
Binary files /dev/null and b/static/imgs/blog/dubbo-go/1.4/k8s.png differ
diff --git a/static/imgs/blog/dubbo-go/1.4/rest.png b/static/imgs/blog/dubbo-go/1.4/rest.png
new file mode 100644
index 0000000..fa867fc
Binary files /dev/null and b/static/imgs/blog/dubbo-go/1.4/rest.png differ
diff --git a/static/imgs/blog/dubbo-go/dubbo-go-arch-2.png b/static/imgs/blog/dubbo-go/dubbo-go-arch-2.png
new file mode 100644
index 0000000..87726d8
Binary files /dev/null and b/static/imgs/blog/dubbo-go/dubbo-go-arch-2.png differ
diff --git a/static/imgs/blog/dubbo-go/hessian/p1.png b/static/imgs/blog/dubbo-go/hessian/p1.png
new file mode 100644
index 0000000..bc0e9af
Binary files /dev/null and b/static/imgs/blog/dubbo-go/hessian/p1.png differ
diff --git a/static/imgs/blog/dubbo-go/hessian/p2.png b/static/imgs/blog/dubbo-go/hessian/p2.png
new file mode 100644
index 0000000..5ba1f60
Binary files /dev/null and b/static/imgs/blog/dubbo-go/hessian/p2.png differ
diff --git a/static/imgs/blog/dubbo-go/hessian/p3.png b/static/imgs/blog/dubbo-go/hessian/p3.png
new file mode 100644
index 0000000..1f1773a
Binary files /dev/null and b/static/imgs/blog/dubbo-go/hessian/p3.png differ
diff --git a/static/imgs/blog/dubbo-go/hessian/p4.png b/static/imgs/blog/dubbo-go/hessian/p4.png
new file mode 100644
index 0000000..45d46c6
Binary files /dev/null and b/static/imgs/blog/dubbo-go/hessian/p4.png differ
diff --git a/static/imgs/blog/dubbo-go/hessian/p5.png b/static/imgs/blog/dubbo-go/hessian/p5.png
new file mode 100644
index 0000000..ca63083
Binary files /dev/null and b/static/imgs/blog/dubbo-go/hessian/p5.png differ
diff --git a/static/imgs/blog/dubbo-go/hessian/p6.png b/static/imgs/blog/dubbo-go/hessian/p6.png
new file mode 100644
index 0000000..2ed25b4
Binary files /dev/null and b/static/imgs/blog/dubbo-go/hessian/p6.png differ
diff --git a/static/imgs/blog/dubbo-go/hessian/p7.png b/static/imgs/blog/dubbo-go/hessian/p7.png
new file mode 100644
index 0000000..cdb2c9e
Binary files /dev/null and b/static/imgs/blog/dubbo-go/hessian/p7.png differ
diff --git a/static/imgs/blog/dubbo-go/hessian/p8.png b/static/imgs/blog/dubbo-go/hessian/p8.png
new file mode 100644
index 0000000..db4e59a
Binary files /dev/null and b/static/imgs/blog/dubbo-go/hessian/p8.png differ
diff --git a/static/imgs/blog/dubbo-go/router/dubbo-admin-1.png b/static/imgs/blog/dubbo-go/router/dubbo-admin-1.png
new file mode 100644
index 0000000..6112cfe
Binary files /dev/null and b/static/imgs/blog/dubbo-go/router/dubbo-admin-1.png differ
diff --git a/static/imgs/blog/dubbo-go/router/dubbo-admin-2.png b/static/imgs/blog/dubbo-go/router/dubbo-admin-2.png
new file mode 100644
index 0000000..10e6993
Binary files /dev/null and b/static/imgs/blog/dubbo-go/router/dubbo-admin-2.png differ
diff --git a/static/imgs/blog/dubbo-go/router/router-design.png b/static/imgs/blog/dubbo-go/router/router-design.png
new file mode 100644
index 0000000..f763f7c
Binary files /dev/null and b/static/imgs/blog/dubbo-go/router/router-design.png differ