![](https://img-blog.csdnimg.cn/75434f810b754ac5b40b03c659b76093.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU5MzU4NjQ4,size_16,color_FFFFFF,t_70#pic_center)

作者｜宋瑞國（塵醉）
來源｜[爾達 Erda 公眾號](https://mp.weixin.qq.com/s/GI7nBWOpIKjraOi_NG9RnQ)

> **導讀**：Erda Infra 微服務框架是從 Erda 專案演進而來，並且完全開源。Erda 基於 Erda Infra 框架完成了大型複雜專案的構建。本文將全面、深入地剖析 Erda Infra 框架的架構設計以及如何使用。

- Erda Infra: [https://github.com/erda-project/erda-infra](https://github.com/erda-project/erda-infra)
- Erda: [https://github.com/erda-project/erda](https://github.com/erda-project/erda)

# 背景
在網際網路技術高速發展的浪潮中，眾多的大型系統慢慢從單體應用演變為微服務化系統。

## 單體應用
單體應用的優勢是開發快速、部署簡單，我們不需要考慮太多就能快速構建出應用，很快地上線產品。

然而，隨著業務的發展，單體程式慢慢變得複雜混亂，非常容易改出 bug，體積也變得越來越大，當業務量上來的時候，很容易崩潰。

## 微服務架構
大型系統往往採用微服務架構，這種架構把複雜的系統拆分成了多個服務，微服務之間松耦合、微服務內部高內聚。

同時，微服務架構也帶來了一些挑戰。服務變多，對整個系統的穩定性是一種挑戰，比如：該如何處理某個服務掛了的情況、服務之間如何通訊、如何觀測系統整體的狀況等。於是，各種各樣的微服務框架誕生了，採用各種技術來解決微服務架構帶來的問題，Spring Cloud 就是一個 Java 領域針對微服務架構的一個綜合性的框架。

## 雲平臺
Spring Cloud 提供了許多技術解決方案，然而對於企業來說，運維成本還是很高。企業需要維護各種中介軟體和眾多的微服務，於是出現了各種各樣的雲服務、雲平臺。

_Erda_ ([https://github.com/erda-project/erda](https://github.com/erda-project/erda)) 是一個針對企業軟體系統在**開發階段**和**運維階段**進行全生命週期管理、一站式的 PaaS 平臺，在各個階段都能夠解決微服務帶來的各種問題。

_Erda_ 本身也是一個非常大的系統，它採用微服務架構來設計，同樣面臨著微服務架構帶來的問題，同時對系統又提出了更多的需求，我們希望實現：

- 系統高度模組化
- 系統具有高擴充套件性
- 適合多人參與的開發模式
- 同時支援 HTTP、gRPC 介面、能自動生成 API Client 等

另一方面，Erda 的開發語言是 golang，在雲原生領域，golang 是一個主流的開發語言，特別適合開發基礎的元件，Docker、Kubernetes、Etcd、Prometheus 等眾多專案也都選用 golang 開發。不像 Spring Cloud 在 Java 中的地位，在 golang 的生態圈裡，沒有一個絕對霸主地位的微服務框架，我們可以找到許多 web 框架、grpc 框架等，他們提供了很多工具，但不會告訴你應該怎麼去設計系統，不會幫你去解耦系統中的模組。

基於這樣的背景，我們開發了 **Erda Infra 框架**。

# Erda Infra 微服務框架
一個大的系統，一般由多個應用程式組成，一個應用程式包含多個模組，**一般的應用程式結構**如下圖所示：

![](https://img-blog.csdnimg.cn/200a5a71a1e4481f9481a1f4ea64c531.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU5MzU4NjQ4,size_16,color_FFFFFF,t_70#pic_center)

這樣的結構存在一些問題：

- **程式碼耦合**：一般會在程式最開始的地方，讀取所有的配置，初始化所有模組，然後啟動一些非同步任務，而這個集中初始化的地方，就是程式碼比較耦合的地方之一。
- **依賴傳遞**：因為模組之間的依賴關係，必須得按照一定的順序初始化，包括資料庫 Client 等，必須得一層層往裡傳遞。
- **可擴充套件性差**：增刪一個模組，並不那麼方便，也很容易影響到其他模組。
- **不利於多人開發**：如果一個應用程式裡的模組是由多人負責開發的，那麼也很容易互相影響，除錯一個模組，也必須得啟動整個應用程式裡的所有模組。

接下來我們透過幾個步驟來解決這些問題。

## 構建以模組驅動的應用程式
我們可以將整個系統拆分為一個個**小的功能點**，每一個**小的功能點**對應一個**微模組**。整個系統像拼圖、搭積木一樣，自由組合各種功能模組為一個大的模組作為獨立的應用程式。

![](https://img-blog.csdnimg.cn/32faf205768549d3a339a8852bd97924.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU5MzU4NjQ4,size_16,color_FFFFFF,t_70#pic_center)

這也意味著我們**無需擔心整個系統的服務過多、過於分散**，只需要**專注於功能本身的拆分**。微服務不僅存在於跨節點的多程式之間，也同樣存在於一個程式內。

![](https://img-blog.csdnimg.cn/c3ac446b81d148c28f11f9b68b400e82.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU5MzU4NjQ4,size_16,color_FFFFFF,t_70#pic_center)

我們利用 Erda Infra 框架來定義一個模組：

```go
package example

import (
	"context"
	"fmt"
	"time"

"github.com/erda-project/erda-infra/base/logs"
	"github.com/erda-project/erda-infra/base/servicehub"
)

// Interface 以介面的形式，對外提供本模組的功能
type Interface interface {
	Hello(name string) string
}

// config 宣告式的配置定義
type config struct {
	Message string `file:"message" flag:"msg" default:"hi" desc:"message to print"`
}

// provider 代表一個模組
type provider struct {
	Cfg *config     // 框架會自動注入
	Log logs.Logger // 框架會自動注入
}

// Init 初始化模組。可選，如果存在，會被框架自動呼叫
func (p *provider) Init(ctx servicehub.Context) error {
	p.Log.Info("message: ", p.Cfg.Message)
	return nil
}

// Run 啟動非同步任務。可選，如果存在，會被框架自動呼叫
func (p *provider) Run(ctx context.Context) error {
	tick := time.NewTicker(3 * time.Second)
	defer tick.Stop()
	for {
		select {
		case  提示：當然這裡也可以內建配置，可以參考 servicehub.RunOptions 裡的定義。

這種方式的優點有以下幾點：

- 面向微模組程式設計，只需要關心自身的功能，更容易做到高內聚、低耦合。
- 宣告式的配置定義，無需關心配置讀取的步驟，框架實現多種方式的配置讀取。
- 無需關心其他模組如何初始化，也無需關心整個應用的初始化順序，只需要專注自身的初始化步驟。
- 非同步任務的管理，框架會處理 程式訊號，優雅的關閉模組任務。
- 系統高度可配置，任意模組都可獨立配置，並且可以單獨啟動某個模組進行除錯。

## 模組間的依賴
正如微服務所面臨的問題之一，服務之間有著複雜的呼叫，客觀上存在著依賴關係。我們將功能模組化之後，該如何解決模組之間的依賴關係。

Erda Infra 給我們提供了**依賴注入**的方式，在介紹依賴注入之前，我們先了解一些概念：

- Service，代表一種可以供其他模組或其他系統使用的功能。
- Provider，代表服務的提供者，提供 0 個或多個服務，相當於一個模組，一組服務集合。
- 一個 Provider 可以依賴 0 個或多個 Service。

我們可以在 Provider 上定義所依賴的 Service 型別作為一個欄位，框架會自動將依賴的 Service 例項注入。

例如，我們定義一個**模組 2**來引用上一節定義的 helloword 模組所提供的 helloworld-service 服務：

```go
package example2

// 以下省略號非關鍵程式碼

import (
	".../example" // your package import path
	"github.com/erda-project/erda-infra/base/servicehub"
)

type provider struct {
	Example example.Interface `autowired:"helloworld-service"` // 框架會自動注入例項
}

func (p *provider) Init(ctx servicehub.Context) error {
	p.Example.Hello("i am module 2")
	return nil
}

func init() {
	// 註冊模組 ...
}

```

可以思考一下，為什麼不是 Provider 之間直接依賴，而是透過 Service 依賴？因為相同的 Service 可以由多個不同實現的 Provider 提供。

正如我們依賴一個介面，而非具體實現類一樣，我們可以將依賴的 Service 介面型別定義在一個公共的地方，由 不同的 Provider 實現來介面，呼叫者無需關心具體實現，我們可以透過配置來切換不同的實現。這樣可以做到模組之間的解耦。

框架可以透過 autowired 宣告的 Service 名稱來進行依賴注入，也可以透過介面型別來進行依賴注入，具體可以參考 Erda Infra 倉庫裡的例子。

框架會分析模組之間的依賴關係，來確定每個模組的初始化順序，所以，當我們編寫一個模組的時候，也就無需關心整個程式裡所有模組的初始化順序了。

## 構建跨程式的 HTTP + gRPC 服務
當解決了模組之間的依賴關係後，我們接下來考慮如何跨程式通訊的問題。

所謂天下大勢，合久必分，分久必合，我們經常會因為一些架構調整或其他原因，需要將部分功能模組遷移到另外的應用程式裡，又或者是將一個大的應用程式拆分為多個小的程式。另一方面，要實現整個系統的所有小功能任意組合為一個大模組，必然也涉及到跨程式的通訊。

好在我們可以進行面向介面的程式設計，模組之間的依賴是透過 Service 介面依賴的，那麼這個介面就有可能是本地的模組，也有可能是遠端的模組。

Erda Infra 可以做到模組之間的解偶，也能解決跨程式通訊的問題，框架透過定義 ProtoBuf API 的方式，為模組提供同時支援 HTTP 和 gRPC 介面的能力：

![](https://img-blog.csdnimg.cn/c6a9cebe28ec46ba94c459f45cf2ffb1.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU5MzU4NjQ4,size_16,color_FFFFFF,t_70#pic_center)

框架也提供了 cli 工具，來幫助我們生成相關的程式碼：

![](https://img-blog.csdnimg.cn/32fe8ea1e3224997a094f349445b9dba.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU5MzU4NjQ4,size_16,color_FFFFFF,t_70#pic_center)

下面我們來看一個例子。

**第一步**，建立一個 greeter.proto 檔案，定義一個 GreeterService 服務：

```protobuf
syntax = "proto3";

package erda.infra.example;
import "google/api/annotations.proto";
option go_package = "github.com/erda-project/erda-infra/examples/service/protocol/pb";

// the greeting service definition.
service GreeterService {
  // say hello
  rpc SayHello (HelloRequest) returns (HelloResponse)  {
    option (google.api.http) = {
      get: "/api/greeter/{name}",
    };
  }
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  bool success = 1;
  string data = 2;
}
```
****

**第二步**，透過 Erda Infra 提供的 gohub 工具，可以編譯出相關的協議程式碼和 Client 模組。

```bash
cd protocol
gohub protoc protocol *.proto 
```
![](https://img-blog.csdnimg.cn/485bbfd3c79847ae9c4f56a9b185410d.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU5MzU4NjQ4,size_16,color_FFFFFF,t_70#pic_center)

其中 protocol/pb 為協議程式碼，protocol/client 為客戶端程式碼

**第三步**，有了協議程式碼，必然需要去實現對應的服務介面，透過 gohub 生成介面實現的程式碼模版：

```bash
cd server/helloworld
gohub protoc imp ../../protocol/*.proto
```
![](https://img-blog.csdnimg.cn/8f7e08f48a8945d19d39788b99b20100.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU5MzU4NjQ4,size_16,color_FFFFFF,t_70#pic_center)

greeter.service.go 檔案內容如下：

```go
package example

import (
	"context"

"github.com/erda-project/erda-infra/examples/service/protocol/pb"
)

type greeterService struct {
	p *provider
}

func (s *greeterService) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloResponse, error) {
	// TODO: 編寫業務邏輯
	return &pb.HelloResponse{
		Success: true,
		Data:    "hello " + req.Name,
	}, nil
}

```

如此一來，就可以開始在模組裡編寫我們的業務邏輯了。

我們編寫好介面的實現後，就同時擁有了 HTTP 和 gRPC 介面，當然這兩種介面是可以選擇性暴露的。

那麼，剛編寫好的模組如何被其他模組所引用呢？

來看下面的例子：

```go
package caller

import (
	"context"
	"time"

"github.com/erda-project/erda-infra/base/logs"
	"github.com/erda-project/erda-infra/base/servicehub"
	"github.com/erda-project/erda-infra/examples/service/protocol/pb"
)

type config struct {
	Name string `file:"name" default:"recallsong"`
}

type provider struct {
	Cfg     *config
	Log     logs.Logger
	Greeter pb.GreeterServiceServer // 由 本地模組 或 遠端模組 提供
}

// 呼叫 GreeterService 服務的例子
func (p *provider) Run(ctx context.Context) error {
	tick := time.NewTicker(3 * time.Second)
	defer tick.Stop()
	for {
		select {
		case

為構建大型複雜系統而生的微服務框架 Erda Infra

相關文章