本文要点：

我们可以基于交互和通信方式将微服务分为两类：外部微服务和内部微服务。
RESTful API是面向外部微服务的事实上的通信技术（REST的无处不在和丰富的生态系统对其取得持续的成功起着至关重要的作用）。
gRPC是远程过程调用（RPC）API范式的一种新的实现，在内部微服务间的同步通信方面发挥重要作用。
在这篇文章里，我们将通过真实的微服务案例来研究gRPC的关键概念，了解将gRPC作为服务间通信的好处及其用法。
很多主流的编程语言都支持gRPC。我们将使用Ballerina和Go作为编程语言来探讨示例。

在现代微服务架构中，我们可以基于微服务的交互和通信方式将微服务分为两种。第一种是直接暴露给消费者的面向外部的微服务。它们主要是基于HTTP的API，这些API使用基于常规文本的消息负载（JSON、XML等，针对外部开发人员进行了优化），并使用REST作为事实上的通信技术。

REST的无处不在和丰富的生态系统对这些面向外部的微服务取得成功起着至关重要的作用。OpenAPI提供了定义良好的规范，用于描述、生成、使用和可视化这些REST API。API管理系统可以很好地与这些API配合使用，并提供安全性、速率限制、缓存和实现业务需求。GraphQL可以替代基于HTTP的REST API，但不在本文讨论范围之内。

另一种是内部微服务，不与外部系统或外部开发人员通信。这些微服务之间相互交互，以便完成给定的任务。内部微服务使用同步或异步通信。在很多情况下，我们可以看到内部微服务使用同步的基于HTTP的REST API，但这并不是最好的技术。在本文中，我们将仔细探究如何利用二进制协议（例如gRPC）作为服务间通信的优化通信协议。

gRPC是什么？

gRPC是用于服务间通信的相对较新的一种远程过程调用（RPC）API范式。与其他RPC一样，它允许位于不同服务器上的应用程序之间相互调用方法，就好像它们是本地对象一样。与Thrift和Avro等其他二进制协议一样，gRPC使用接口描述语言（IDL）来定义服务契约。gRPC使用HTTP/2（最新的网络传输协议）作为默认传输协议，与基于HTTP/1.1的REST相比，gRPC更快、更强大。

你可以使用Protocol Buffers来定义gRPC服务契约，每个服务定义指定方法数量，这些方法包含了期望的输入和输出消息以及参数和返回类型的数据结构。使用主流编程语言提供的工具，基于Protocol Buffers文件生成服务器端框架和客户端代码（存根）。

一个实际的gRPC微服务案例

图1：一个在线零售商店微服务架构图片段

微服务架构的一个主要好处是可以使用最合适的编程语言来构建不同的服务，而不是只使用一种语言来构建所有服务。图1展示了在线零售商店微服务架构的一部分，其中使用Ballerina实现了四个微服务（在本文的其余部分用Ballerina代称），使用Go实现了其他一些功能。由于主流的编程语言都支持gRPC，因此当我们在定义服务契约时，可以指定一种合适的编程语言。

syntax="proto3";
 
package retail_shop;
 
service OrderService {
   rpc UpdateOrder(Item) returns (Order);
}  
message Item {
   string itemNumber = 1;
   int32 quantity = 2;
}
message Order {
   string itemNumber = 1;
   int32 totalQuantity = 2;
   float subTotal = 3;
}

清单1：Order微服务的服务契约(order.proto)
Order微服务根据购物项目和数量返回小计金额。在这里，我使用Ballerina gRPC工具分别生成gRPC服务端样板代码和客户端代码。

$ ballerina grpc --mode service --input proto/order.proto --output gen_code

生成的OrderService服务器端样板代码如下：

import ballerina/grpc;
listener grpc:Listener ep = new (9090);
 
service OrderService on ep {
   resource function UpdateOrder(grpc:Caller caller, Item value) {
       // 具体实现
       // 返回一个Order对象
   }
}
public type Order record {|
   string itemNumber = "";
   int totalQuantity = 0;
   float subTotal = 0.0;
|};
public type Item record {|
   string itemNumber = "";
   int quantity = 0;
|};

清单2：生成的样板代码片段（OrderService_sample_service.bal）
gRPC的rpc映射到Ballerina的service类型，gRPC的rpc映射到Ballerina的resource function，gRPC的message映射到Ballerina的record类型。

我为Order微服务创建了一个单独的Ballerina项目，并使用生成的OrderService样板代码来实现gRPC服务。

一元阻塞（Unary Blocking）

OrderService被Cart微服务调用。我们可以使用下面的Ballerina命令来生成客户端存根和代码。

$ ballerina grpc --mode client --input proto/order.proto --output gen_code

生成的客户端存根同时具有阻塞和非阻塞远程方法。这个示例代码演示了gRPC一元服务如何与gRPC阻塞客户端交互。

public remote function UpdateOrder(Item req, grpc:Headers? headers = ()) returns ([Order, grpc:Headers]|grpc:Error) {
       var payload = check self.grpcClient->blockingExecute("retail_shop.OrderService/UpdateOrder", req, headers);
       grpc:Headers resHeaders = new;
       anydata result = ();
       [result, resHeaders] = payload;
       return [<Order>result, resHeaders];
   }
};

清单3：生成的阻塞模式远程对象代码片段
Ballerina的远程方法抽象与gRPC客户端存根完美契合，你可以看到UpdateOrder调用代码是多么干净和整洁。

Checkout微服务对所有从Cart微服务收到的临时订单进行聚合，并生成最终的账单。在本例中，我们将以订单消息流的形式发送所有临时订单。

syntax="proto3";
package retail_shop;
 
service CheckoutService {
   rpc Checkout(stream Order) returns (FinalBill) {}
}
message Order {
   string itemNumber = 1;
   int32 totalQuantity = 2;
   float subTotal = 3;
}
message FinalBill {
   float total = 1;
}

清单4：Checkout微服务的服务契约（checkout.proto）
你可以使用ballerina grpc命令为checkout.proto生成样板代码。

$ ballerina grpc --mode service --input proto/checkout.proto --output gen_code

gRPC客户端流

Cart微服务将消息流作为流对象参数，可以使用循环来访问，以便处理客户端发送的每一个消息。请看下面的实现：

service CheckoutService on ep {
   resource function Checkout(grpc:Caller caller, stream<Order,error> clientStream) {
       float totalBill = 0;
       //在这里访问消息流
       error? e = clientStream.forEach(function(Order order) {
           totalBill += order.subTotal;           
       });
       //客户端的消息流结束时会返回一个grpc:EOS错误
       if (e is grpc:EOS) {
           FinalBill finalBill = {
               total:totalBill
           };
           //将总账单发送给客户端
           grpc:Error? result = caller->send(finalBill);
           if (result is grpc:Error) {
               log:printError("Error occurred when sending the Finalbill: " + 
result.message() + " - " + <string>result.detail()["message"]);
           } else {
               log:printInfo ("Sending Final Bill Total: " + 
finalBill.total.toString());
           }
           result = caller->complete();
           if (result is grpc:Error) {
               log:printError("Error occurred when closing the connection: " + 
result.message() +" - " + <string>result.detail()["message"]);
           }
       }
       //如果客户端发送的是一个错误，可以这么处理
       else if (e is grpc:Error) {
           log:printError("An unexpected error occured: " + e.message() + " - " +
                                                   <string>e.detail()["message"]);
       }   
   }
}

清单5：CheckoutService实现代码片段（CheckoutService_sample_service.bal）
一旦客户端流结束，将返回grpc:EOS错误，这个错误可用来确定何时使用调用者对象向客户端发送最终响应消息(聚合总数)。

示例客户端代码和客户端存根可以使用以下命令生成：

$ ballerina grpc --mode client --input proto/checkout.proto --output gen_code

我们来看一下Cart微服务的实现。Cart微服务有两个REST API——一个用于向购物车添加商品，另一个用于执行最终的结账。在向购物车添加商品时，通过gRPC调用Order微服务，并将其保存在内存中，它将获得一个带有每个商品小计金额的临时订单。调用Checkout微服务将把所有保存在内存中的临时订单以gRPC流的形式发送给Checkout微服务，并返回需要支付的总额。Ballerina使用内置的Stream类型和Client Object抽象来实现gRPC客户端流。图2演示了Ballerina的客户端流是如何工作的。

图2：Ballerina gRPC客户端流

CheckoutService客户端流的完整实现可以在Cart微服务的checkout resource function中找到。最后，在结账过程中，通过gRPC调用使用Go实现的Stock微服务，并扣除已售商品，更新库存。

syntax="proto3";
package retail_shop;
option go_package = "../stock;gen";
import "google/api/annotations.proto";
 
service StockService {
   rpc UpdateStock(UpdateStockRequest) returns (Stock) {
       option (google.api.http) = {
           // 路由到/api/v1/stock
           put: "/api/v1/stock"
           body: "*"
       };
   }
}
message UpdateStockRequest {
   string itemNumber = 1;
   int32 quantity = 2;
}
message Stock {
   string itemNumber = 1;
   int32 quantity = 2;
}

清单6：Stock微服务的服务契约（stock.proto）
在这个场景中，UpdateStock服务作为外部API（通过REST API来调用），也可以通过gRPC进行服务间调用。grpc-gateway是protoc的一个插件，它读取gRPC服务定义并生成一个反向代理服务器，将RESTful JSON API转换为gRPC。

图3：grpc-gateway

你可以借助grpc-gateway同时提供gRPC和REST风格的API。

使用以下命令生成Golang gRPC存根：

protoc -I/usr/local/include -I. \
-I$GOROOT/src \
-I$GOROOT/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis \
--go_out=plugins=grpc:. \
stock.proto

使用以下命令生成Golang grpc-gateway代码：

protoc -I/usr/local/include -I. \
-I$GOROOT/src \
-I$GOROOT/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis \
--grpc-gateway_out=logtostderr=true:. \
stock.proto

使用以下命令生成stock.swagger.json：

protoc -I/usr/local/include -I. \
-I$GOROOT/src \
-I$GOROOT/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis \
-I$GOROOT/src \
--swagger_out=logtostderr=true:../stock/gen/. \
./stock.proto

运行示例代码

拉取microservices-with-grpc代码库，并参看READEME.md。

结论

gRPC虽然还年轻，但其快速增长的生态系统和社区肯定会对微服务的发展产生影响。由于gRPC是一种开放标准，所有主流编程语言都支持它，这使得它非常适合被用在多语言微服务环境中。作为一种常规做法，我们可以将gRPC用于内部微服务之间的同步通信。借助grpc-gateway等新兴技术，我们还可以将其包装成REST风格的API。除了本文讨论的内容之外，gRPC特性(如超时、取消、通道和xDS支持)将为开发人员构建高效的微服务提供强大的功能和灵活性。

更多资源

要了解更多有Ballerina gRPC的资料，请浏览以下链接：

Go提供了全面的gRPC支持，我们可以扩展这些微服务，通过使用gRPC拦截器、超时、取消和渠道等来增强安全性、健壮性和弹性。请参阅grpc-go代码库，其中有很多有关这些概念的示例。

推荐视频：

Generating Unified APIs with Protocol Buffers and gRPC

Writing REST Services for the gRPC curious

Using gRPC for Long-lived and Streaming RPCs

作者介绍：

Lakmal Warusawithana是WSO2的高级开发总监。2005年，Lakmal与其他人共同创立了thinkCube，这是为电信运营商量身定制的下一代协同云计算产品的先驱。他监督整个工程过程，特别关注thinkCube解决方案的可扩展性和服务交付。在创立thinkCube之前，Lakmal在ITABS工作了4年，这是一家专门从事Linux服务器部署的公司，提供易于使用的定制服务器管理界面。

原文链接：

Building Effective Microservices with gRPC, Ballerina, and Go

创作场景

如何使用 gRPC、Ballerina 和 Go 开发高效的微服务