安科网

ScalaPB（5）：用akka-stream实现reactive-gRPC

编程语言与高级语言虚拟机杂谈仮

编程语言与高级语言虚拟机杂谈仮

2018-05-21

关注 关注

在前面几篇讨论里我们介绍了scala-gRPC的基本功能和使用方法，我们基本确定了选择gRPC作为一种有效的内部系统集成工具，主要因为下面gRPC支持的几种服务模式：

、Unary-Call：独立的一对client-request/server-response，是我们常用的http交互模式

、Server-Streaming：client发出一个request后从server端接收一串多个response

、Client-Streaming：client向server发送一串多个request后从server接收一个response

、Bidirectional-Streaming：由client首先发送request启动连接，然后在这个连接上两端可以不断交互信息。

很明显，gRPC支持双向的streaming。那么如果能把gRPC中ListenableFuture和StreamObserver这两种类型转成akka-stream的基本类型应该就能够实现所谓的reactive-gRPC了。如果我们能用akka-stream编程方式实现gRPC服务调用的话，可能会遭遇下面的场景：在服务端我们只需要实现一种akka-stream的Flow把进来的request转化成出去的response，如下：

// Unary case
Flow[Request].map(computeResponse)
 
// Server streaming
Flow[Request].flatMapConcat(computeResponses)
 
// Client streaming
Flow[Request].fold(defaultResponse)(computeResponse)
 
// Bidirectional streaming
Flow[Request].flatMapConcat(computeResponses)

当然，这是个akka-stream Flow，我们可以在这个Flow里调用任何akka-stream提供的功能，如：

Flow[Request]
  .throttle(1, 10.millis, 1, ThrottleMode.Shaping)
  .map(computeResponse)

在客户端我们可以直接经客户端stub调用Flow，如下：

Source
  .single(request)
  .via(stub.doSomething)
  .runForeach(println)

刚好，beyond-the-lines gRPCAkkaStream开源项目提供这么一种gRPC StreamObserver到aka-stream Flow转换桥梁。下面是gRPCAkkaStream的使用示范。先从Unary-Call开始：下面是.proto文件的IDL服务描述：

syntax = "proto3";
package learn.grpc.akka.stream.services;
message NumPair {
   int32 num1 = ;
   int32 num2 = ;
}
message Num {
   int32 num = ;
}
message SumResult {
   int32 result = ;
}
service SumNumbers {
   rpc SumPair(NumPair) returns (SumResult) {}
}

我们看看编译后自动产生的SumGrpcAkkaStream.scala文件中一些相关类型和函数：

服务界面描述：

trait SumNumbers extends AbstractService {
    override def serviceCompanion = SumNumbers
    def sumPair: Flow[learn.grpc.akka.stream.services.sum.NumPair, learn.grpc.akka.stream.services.sum.SumResult, NotUsed]
}

我们看到服务函数sumPair是一个akka-stream Fow[NumPair,SumResult,NotUsed]。下面是具体实现SumNumbers.sumPair代码：

class gRPCAkkaStreamService extends SumGrpcAkkaStream.SumNumbers {
  val logger: Logger = Logger.getLogger(classOf[gRPCAkkaStreamService].getName)
    override def sumPair: Flow[NumPair, SumResult, NotUsed] = {
      logger.info(s"*** calling sumPair ...  ***")
      Flow[NumPair].map {
        case NumPair(a,b) => {
          logger.info(s"serving ${a} + ${b} = ???")
          SumResult(a + b)
        }
      }
    }

产生的客户端stub源代码如下：

class SumNumbersStub(
    channel: Channel,
    options: CallOptions = CallOptions.DEFAULT
  ) extends AbstractStub[SumNumbersStub](channel, options) with SumNumbers {
    override def sumPair: Flow[learn.grpc.akka.stream.services.sum.NumPair, learn.grpc.akka.stream.services.sum.SumResult, NotUsed] =
      Flow[learn.grpc.akka.stream.services.sum.NumPair].flatMapConcat(request =>
        Source.fromFuture(
          Grpc.guavaFuture2ScalaFuture(
            ClientCalls.futureUnaryCall(channel.newCall(METHOD_SUM_PAIR, options), request)
          )
        )
      )
  
 def stub(channel: Channel): SumNumbersStub = new SumNumbersStub(channel)

我们可以通过stub来调用sumPair方法，如下：

val channel = ManagedChannelBuilder
      .forAddress(host,port)
      .usePlaintext(true)
      .build()

  val stub = SumGrpcAkkaStream.stub(channel)

  def addPair(num1: Int, num2: Int): Source[String,NotUsed] = {
    logger.info(s"Requesting to add $num1, $num2")
    Source
      .single(NumPair(num1,num2))
      .via(stub.sumPair)
      .map(r => s"the result: ${r.result}")
  }

下面是Unary-Call的具体调用方式：

object UnaryCallClient extends App {
  implicit val system = ActorSystem("UnaryClient")
  implicit val mat = ActorMaterializer.create(system)

  val client = new gRPCAkkaStreamClient("localhost", 50051)

  client.addPair(29,33).runForeach(println)

  scala.io.StdIn.readLine()
  mat.shutdown()
  system.terminate()

}

在Server-Streaming中一个request返回的是stream of responses。IDL的描述如下：

service SumNumbers {
   rpc SumPair(NumPair) returns (SumResult) {}
   rpc GenIncsFrom(Num) returns (stream Num) {}
}

编译后自动产生的service trait如下：

trait SumNumbers extends AbstractService {
    override def serviceCompanion = SumNumbers
    def sumPair: Flow[learn.grpc.akka.stream.services.sum.NumPair, learn.grpc.akka.stream.services.sum.SumResult, NotUsed]
    def genIncsFrom: Flow[learn.grpc.akka.stream.services.sum.Num, learn.grpc.akka.stream.services.sum.Num, NotUsed]
  }

这个服务函数genIncsFrom是Flow[Num,Num,NotUsed]，它的具体实现如下：

class gRPCAkkaStreamService extends SumGrpcAkkaStream.SumNumbers {
  val logger: Logger = Logger.getLogger(classOf[gRPCAkkaStreamService].getName)
  override def genIncsFrom: Flow[Num, Num, NotUsed] = {
    logger.info("*** calling genIncsFrom")
    Flow[Num].mapConcat {
      n => ( to n.num).map {m =>
        logger.info(s"genIncFrom producing num: ${m}")
        Num(m)
      }
    }
  }
}

因为输出response是一个stream，可以用mapConcat展平Seq来产生一个。在客户方调用服务函数genIncsFrom的方式如下：

def genIncNumbers(len: Int): Source[Int,NotUsed] = {
    logger.info(s"Requesting to produce ${len} inc numbers")
    Source
      .single(Num(len))
      .via(stub.genIncsFrom)
      .map(n => n.num)
  }

我们还是用runForeach来运算这个Source：

object ServerStreamingClient extends App {
  implicit val system = ActorSystem("ServerStreamingClient")
  implicit val mat = ActorMaterializer.create(system)

  val client = new gRPCAkkaStreamClient("localhost", )

  client.genIncNumbers().runForeach(println)

  scala.io.StdIn.readLine()
  mat.shutdown()
  system.terminate()

}

再来看看Client-Streaming是如何通过reactive-stream实现的。IDL服务描述如下：

service SumNumbers {
   rpc SumPair(NumPair) returns (SumResult) {}
   rpc GenIncsFrom(Num) returns (stream Num) {}
   rpc SumStreamNums(stream Num) returns (SumResult) {}
}

自动产生的service接口如下：

trait SumNumbers extends AbstractService {
    override def serviceCompanion = SumNumbers
    def sumPair: Flow[learn.grpc.akka.stream.services.sum.NumPair, learn.grpc.akka.stream.services.sum.SumResult, NotUsed]
    def genIncsFrom: Flow[learn.grpc.akka.stream.services.sum.Num, learn.grpc.akka.stream.services.sum.Num, NotUsed]
    def sumStreamNums: Flow[learn.grpc.akka.stream.services.sum.Num, learn.grpc.akka.stream.services.sum.SumResult, NotUsed]
  }

sumStreamNums Flow实现如下：

override def sumStreamNums: Flow[Num, SumResult, NotUsed] = {
    logger.info("*** calling sumStreamNums")
    Flow[Num].fold(SumResult()) {
      case (a, b) =>
        logger.info(s"receiving operand ${b.num}")
        SumResult(b.num + a.result)
    }
  }

request是一个stream，可以用aggregation来汇总成一个response。在客户端调用stub.sumStreamNums：

def sumManyNumbers(nums: Seq[Int]): Source[String,NotUsed] = {
    logger.info(s"Requesting to sum up ${nums}")
    Source(nums.map(Num(_)).to[collection.immutable.Iterable])
      .via(stub.sumStreamNums)
      .map(r => s"the result: ${r.result}")
    }

object ClientStreamingClient extends App {
  implicit val system = ActorSystem("ClientStreamingClient")
  implicit val mat = ActorMaterializer.create(system)

  val client = new gRPCAkkaStreamClient("localhost", 50051)

  client.sumManyNumbers(Seq(12,4,8,19)).runForeach(println)

  scala.io.StdIn.readLine()
  mat.shutdown()
  system.terminate()

}

最后我们示范一下BiDirectional-Streaming。先用IDL定义一个流输入输出的服务函数keepAdding：

service SumNumbers {
   rpc SumPair(NumPair) returns (SumResult) {}
   rpc GenIncsFrom(Num) returns (stream Num) {}
   rpc SumStreamNums(stream Num) returns (SumResult) {}
   rpc KeepAdding(stream Num) returns (stream SumResult) {}
}

这个函数的实现代码：

override def keepAdding: Flow[Num, SumResult, NotUsed] = {
    Flow[Num].scan(SumResult()) {
      case (a,b) =>
        logger.info(s"receiving operand ${b.num}")
        SumResult(b.num + a.result)
    }
  }

这个服务函数的作用是把一串输入数字逐个相加并输出当前结果。我们可以用scan来实现这样的功能。下面是客户端调用服务的示范代码：

def ContSum(nums: Seq[Int]): Source[String,NotUsed] = {
    logger.info(s"Requesting to sum up ${nums}")
    Source(nums.map(Num(_)).to[collection.immutable.Iterable])
      .throttle(1, 500.millis, 1, ThrottleMode.shaping)
      .map { n =>
        logger.info(s"Sending number: $n")
        n
      }
      .via(stub.keepAdding)
      .map(r => s"current sum = ${r.result}")
  }

用下面这段代码运算：

object BiDiStreamingClient extends App {
  implicit val system = ActorSystem("BiDiStreamingClient")
  implicit val mat = ActorMaterializer.create(system)

  val client = new gRPCAkkaStreamClient("localhost", 50051)

  client.ContSum(Seq(12,4,8,19)).runForeach(println)

  scala.io.StdIn.readLine()
  mat.shutdown()
  system.terminate()

}

好，下面是本次讨论涉及的所有源代码：

project/scalapb.sbt

addSbtPlugin("com.thesamet" % "sbt-protoc" % "0.99.18")

resolvers += Resolver.bintrayRepo("beyondthelines", "maven")

libraryDependencies ++= Seq(
  "com.thesamet.scalapb" %% "compilerplugin" % "0.7.1",
  "beyondthelines"         %% "grpcakkastreamgenerator" % "0.0.5"
)

build.sbt

import scalapb.compiler.Version.scalapbVersion
import scalapb.compiler.Version.grpcJavaVersion

name := "gRPCAkkaStreamDemo"

version := "0.1"

scalaVersion := "2.12.6"

resolvers += Resolver.bintrayRepo("beyondthelines", "maven")

libraryDependencies ++= Seq(
  "com.thesamet.scalapb" %% "scalapb-runtime" % scalapbVersion % "protobuf",
  "io.grpc" % "grpc-netty" % grpcJavaVersion,
  "com.thesamet.scalapb" %% "scalapb-runtime-grpc" % scalapbVersion,
  "io.monix" %% "monix" % "2.3.0",
  // for GRPC Akkastream
  "beyondthelines"         %% "grpcakkastreamruntime" % "0.0.5"
)

PB.targets in Compile := Seq(
  scalapb.gen() -> (sourceManaged in Compile).value,
  // generate the akka stream files
  grpc.akkastreams.generators.GrpcAkkaStreamGenerator() -> (sourceManaged in Compile).value
)

src/main/protobuf/sum.proto

syntax = "proto3";

package learn.grpc.akka.stream.services;


message NumPair {
   int32 num1 = ;
   int32 num2 = ;
}

message Num {
   int32 num = ;
}

message SumResult {
   int32 result = ;
}

service SumNumbers {
   rpc SumPair(NumPair) returns (SumResult) {}
   rpc GenIncsFrom(Num) returns (stream Num) {}
   rpc SumStreamNums(stream Num) returns (SumResult) {}
   rpc KeepAdding(stream Num) returns (stream SumResult) {}
}

src/main/scala/gRPCAkkaStreamService.scala

package learn.grpc.akka.stream.services.impl

import akka.NotUsed
import akka.stream.scaladsl.Flow
import learn.grpc.akka.stream.services.sum._
import java.util.logging.Logger

class gRPCAkkaStreamService extends SumGrpcAkkaStream.SumNumbers {
  val logger: Logger = Logger.getLogger(classOf[gRPCAkkaStreamService].getName)

  override def sumPair: Flow[NumPair, SumResult, NotUsed] = {
    logger.info(s"*** calling sumPair ...  ***")
    Flow[NumPair].map {
      case NumPair(a, b) => {
        logger.info(s"serving ${a} + ${b} = ???")
        SumResult(a + b)
      }
    }
  }

  override def genIncsFrom: Flow[Num, Num, NotUsed] = {
    logger.info("*** calling genIncsFrom ... ***")
    Flow[Num].mapConcat {
      n =>
        ( to n.num).map { m =>
          logger.info(s"genIncFrom producing num: ${m}")
          Num(m)
        }
    }
  }

  override def sumStreamNums: Flow[Num, SumResult, NotUsed] = {
    logger.info("*** calling sumStreamNums ... ***")
    Flow[Num].fold(SumResult()) {
      case (a, b) =>
        logger.info(s"receiving operand ${b.num}")
        SumResult(b.num + a.result)
    }
  }

  override def keepAdding: Flow[Num, SumResult, NotUsed] = {
    Flow[Num].scan(SumResult()) {
      case (a,b) =>
        logger.info(s"receiving operand ${b.num}")
        SumResult(b.num + a.result)
    }
  }
}

src/main/scala/gRPCAkkaStreamServer.scala

package learn.grpc.akka.stream.server

import java.util.logging.Logger

import akka.actor.ActorSystem
import akka.stream.ActorMaterializer
import io.grpc.Server
import learn.grpc.akka.stream.services.impl.gRPCAkkaStreamService
import io.grpc.ServerBuilder
import learn.grpc.akka.stream.services.sum._
class gRPCServer(server: Server) {

  val logger: Logger = Logger.getLogger(classOf[gRPCServer].getName)

  def start(): Unit = {
    server.start()
    logger.info(s"Server started, listening on ${server.getPort}")
    sys.addShutdownHook {
      // Use stderr here since the logger may has been reset by its JVM shutdown hook.
      System.err.println("*** shutting down gRPC server since JVM is shutting down")
      stop()
      System.err.println("*** server shut down")
    }
    ()
  }

  def stop(): Unit = {
    server.shutdown()
  }

  /**
    * Await termination on the main thread since the grpc library uses daemon threads.
    */
  def blockUntilShutdown(): Unit = {
    server.awaitTermination()
  }
}

object DemoServer extends App {
  implicit val system = ActorSystem("UnaryServer")
  implicit val mat = ActorMaterializer.create(system)
  val server = new gRPCServer(
    ServerBuilder
      .forPort()
        .addService(
          SumGrpcAkkaStream.bindService(
           new gRPCAkkaStreamService
          )
      ).build()
  )
  server.start()
//  UnaryServer.blockUntilShutdown()
  scala.io.StdIn.readLine()
  mat.shutdown()
  system.terminate()

}

src/main/scala/gRPCAkkaStreamClient.scala

package learn.grpc.akka.stream.client
import learn.grpc.akka.stream.services.sum._
import java.util.logging.Logger

import akka.stream.scaladsl._
import akka.NotUsed
import akka.actor.ActorSystem
import akka.stream.{ActorMaterializer, ThrottleMode}
import scala.concurrent.duration._
import io.grpc._
class gRPCAkkaStreamClient(host: String, port: Int) {
  val logger: Logger = Logger.getLogger(classOf[gRPCAkkaStreamClient].getName)

  val channel = ManagedChannelBuilder
      .forAddress(host,port)
      .usePlaintext(true)
      .build()

  val stub = SumGrpcAkkaStream.stub(channel)

  def addPair(num1: Int, num2: Int): Source[String,NotUsed] = {
    logger.info(s"Requesting to add $num1, $num2")
    Source
      .single(NumPair(num1,num2))
      .via(stub.sumPair)
      .map(r => s"the result: ${r.result}")
  }
  def genIncNumbers(len: Int): Source[Int,NotUsed] = {
    logger.info(s"Requesting to produce ${len} inc numbers")
    Source
      .single(Num(len))
      .via(stub.genIncsFrom)
      .map(n => n.num)
  }
  def sumManyNumbers(nums: Seq[Int]): Source[String,NotUsed] = {
    logger.info(s"Requesting to sum up ${nums}")
    Source(nums.map(Num(_)).to[collection.immutable.Iterable])
      .throttle(1, 500.millis, 1, ThrottleMode.shaping)
      .map { n =>
        logger.info(s"Sending number: $n")
        n
      }
      .via(stub.sumStreamNums)
      .map(r => s"the result: ${r.result}")
    }
  def ContSum(nums: Seq[Int]): Source[String,NotUsed] = {
    logger.info(s"Requesting to sum up ${nums}")
    Source(nums.map(Num(_)).to[collection.immutable.Iterable])
      .throttle(1, 500.millis, 1, ThrottleMode.shaping)
      .map { n =>
        logger.info(s"Sending number: $n")
        n
      }
      .via(stub.keepAdding)
      .map(r => s"current sum = ${r.result}")
  }
}

object UnaryCallClient extends App {
  implicit val system = ActorSystem("UnaryClient")
  implicit val mat = ActorMaterializer.create(system)

  val client = new gRPCAkkaStreamClient("localhost", 50051)

  client.addPair(29,33).runForeach(println)

  scala.io.StdIn.readLine()
  mat.shutdown()
  system.terminate()

}

object ServerStreamingClient extends App {
  implicit val system = ActorSystem("ServerStreamingClient")
  implicit val mat = ActorMaterializer.create(system)

  val client = new gRPCAkkaStreamClient("localhost", 50051)

  client.genIncNumbers(5).runForeach(println)

  scala.io.StdIn.readLine()
  mat.shutdown()
  system.terminate()

}

object ClientStreamingClient extends App {
  implicit val system = ActorSystem("ClientStreamingClient")
  implicit val mat = ActorMaterializer.create(system)

  val client = new gRPCAkkaStreamClient("localhost", 50051)

  client.sumManyNumbers(Seq(12,4,8,19)).runForeach(println)

  scala.io.StdIn.readLine()
  mat.shutdown()
  system.terminate()

}

object BiDiStreamingClient extends App {
  implicit val system = ActorSystem("BiDiStreamingClient")
  implicit val mat = ActorMaterializer.create(system)

  val client = new gRPCAkkaStreamClient("localhost", 50051)

  client.ContSum(Seq(12,4,8,19)).runForeach(println)

  scala.io.StdIn.readLine()
  mat.shutdown()
  system.terminate()

}

grpc flow

编程语言与高级语言虚拟机杂谈仮

编程语言与高级语言虚拟机杂谈仮

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

.Net Core中使用Grpc的方法

　　gRPC 基于如下思想：定义一个服务， 指定其可以被远程调用的方法及其参数和返回类型。gRPC 默认使用protocol buffers作为接口定义语言，来描述服务接口和有效载荷消息结构。如果有需要的话，可以使用其他替代方案。服务端流式 RPC，即客户

darren0zdc 2020-10-16

java 通过 Grpc 与c 通信

由于项目是java 和 c 开发的并且各自独立部署，所以涉及业务需要进行java 与c 通信；根据自测grpc 客户端发现，grpc 支持自动重连、自动判断服务是否上线；

ltstud 2020-07-24

思考gRPC ：为什么是HTTP/2

§。§

岁月如歌 2020-07-21

grpc 安装

安装请参考官方资料-快速开始，安装gRPC需要安装Go、protocol buffer、protoc-gen-go、gRPC等。windows下直接下载编译好的包，然后将bin目录加到环境变量。这是因为grpc的版本和protoc-gen-go版本不一致造

Erick 2020-07-18

golang使用grpc

我的网络通信概念还停留在比较基础的地方, 直觉来说就是发送一个get/post请求, 设定一定的参数格式, 这样对方再解析你的数据, 基于此完成通讯.而rpc则不使用这种显式的通讯方式, 通过proto与生成grpc文件, 里面提供方法, 供client与

wujingsheng0 2020-06-16

Asp.net core 通过grpc调用python

简单来说就是远程过程调用。举个例子，比如在C#代码中直接调用python 中写的方法，或者一个C#进程调用另一个C#进程中的方法，或者其他语言之间的互相调用。具体书写方法可百度。syntax = "proto3"; //表示用的是pro

xmwang0 2020-06-14

【gRPC】 在.Net core中使用gRPC

gRPC是一个高性能的通信协议，它基于HTTP/2和protocol buffers。它是微服务之间进行同步通信的主要选择。与之相对的，就是其他协议，如AMQP的异步通信队列或者发布/订阅模式。RPC框架实际是提供了一套机制，使得应用程序之间可以进行通信，

极品小肥羊 2020-05-31

微服务开发手册之GRPC

> GRPC是一个高性能、通用的开源RPC框架，基于HTTP/2协议标准和Protobuf序列化协议开发，支持众多的开发语言。gRPC使用protocol buffers作为接口描述语言以及底层的信息交换格式，一般情况下推荐使用 proto3因为其能

小小书童 2020-05-20

gRPC 介绍和简单实现

　　gRPC是Google公司基于Protobuf开发的跨语言的开源RPC框架。gRPC基于HTTP/2协议设计，可以基于一个HTTP/2链接提供多个服务，对于移动设备更加友好。本节将讲述gRPC的简单用法。　　最底层为TCP或Unix Socket协议，

极品小肥羊 2020-04-23

gRPC怎样节省您的开发时间

此时，您应该已经听说过" gRPC"。在本文中，我将着重介绍采用gRPC作为微服务之间的通信介质的好处。首先，我将尝试简要介绍一下架构演变的历史。其次，我将重点介绍使用REST和可能出现的问题。最后，我将以我的开发工作流程为例。一切都在

小小书童 2020-04-10

Service Mesh - gRPC 本地联调远程服务

Service Mesh 架构下，服务间调用会通过服务名互相调用，比如在 Kubernetes 、Docker Swarm 集群中，服务 IP 均由集群动态分配，外部网络无法直接访问到集群内部的服务。比较优雅一点的做法是本地启动相应服务，gRPC 调用都连

君小黑 2020-03-04

GRPC协议的相关原理

GRPC的Client与Server，均通过Netty Channel作为数据通信，序列化、反序列化则使用Protobuf，每个请求都将被封装成HTTP2的Stream，在整个生命周期中，客户端Channel应该保持长连接，而不是每次调用重新创建Chann

naiwenw 2020-02-18

使用gRPC-Web从浏览器调用.NET gRPC服务

我很高兴宣布通过.NET对gRPC-Web进行实验性支持。gRPC-Web允许从基于浏览器的应用程序调用gRPC。gRPC-Web通过与HTTP / 1.1和HTTP / 2兼容来解决此问题。gRPC-Web不是一项新技术。有一个稳定的gRPC-Web J

小小书童 2020-02-22

一个新实验：使用gRPC-Web从浏览器调用.NET gRPC服务

今天给大家翻译一篇由ASP.NET首席开发工程师James Newton-King前几天发表的一篇博客，文中带来了一个实验性的产品gRPC-Web。大家可以点击文末的讨论帖进行相关反馈。我会在文章末尾给出原文链接。我很高兴宣布通过.NET对gRPC-Web

dabaoge 2020-02-16

ASP.NET Core 3.0 gRPC拦截器的使用

前面两篇文章给大家介绍了使用gRPC的入门以及双向流的使用，今天介绍的是gRPC中的拦截器。拦截器就像MVC的过滤器或者是ASP.NET Core middleware 一样，具有面向切面的思想，可以在调用服务的时候进行一些统一处理， 很适合在这里处理验证

小小书童 2019-12-23

ASP.NET Core 3.0使用gRPC的具体方法

gRPC ±Googleè·¨èè¨é§èè¨è¨è°¨RPC gRPC·¨¨é°èèéè¨HTTP/2éè¨ Protocol Buffers è。Grpc.AspNetCore ¨¨ASP.NET CoreègRPC° gRPCASP.NET Core

dabaoge 2020-01-25

gRPC - macOS missing ALPN support.

请将 Kestrel 和 gRPC 客户端配置为在不使用 TLS 的情况下使用 HTTP/2。只应在开发过程中执行此操作。如果不使用 TLS，将会在不加密的情况下发送 gRPC 消息。如果没有 TLS，与端点的所有连接默认为 HTTP/1.1，并且 gRP

MAC2007 2020-01-17

window64+mingw+grpc（一）

网上很多都是window+vs+grpc，看了很多帖子都无法通过mingw编译grpc，遇到的问题罗列一下

dabaoge 2020-01-13

在Python中使用gRPC的方法示例【h】

使用Protocol Buffers的跨平台RPC系统。gRPC由两个部分构成，grpcio 和 gRPC 工具， 后者是编译 protocol buffer 以及提供生成代码的插件。使用 gRPC 首先需要做的是设计 protocol buffer。以上

duanlove技术路途 2019-12-28

Go gRPC 调试工具

最近这段时间工作挺忙的，发现已经 3 周没更文了...感谢你们还在，今天给大家分享一款 gRPC 的调试工具。当我们在写 HTTP 接口的时候，使用的是 Postman 进行接口调试，那么在写 gRPC 接口的时候，有没有类似于 Postman 的调试工具

ltstud 2020-01-10
编程语言与高级语言虚拟机杂谈仮

编程语言与高级语言虚拟机杂谈仮

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号