标签: grpc

我使用Link提供的示例在C#中创建了一个GRPC服务器.现在我想弄清楚我应该如何托管这个服务器,以便我实现以下目标:

• 我应该将此服务器设置为控制台应用程序还是Windows服务.如果我把它变成一个Windows服务,那么更新服务将是麻烦的(这是一个很大的负面),如果我把它变成一个控制台应用程序,那么更新将只需要关闭exe.但这与错误关闭相同的价格有关.还有其他更好的方法吗？
• 使用IIS时,这个问题不会出现,因为我可以简单地从LB中删除该站点并停止网站执行更新,但由于GRPC不会成为IIS的一部分,我不确定是什么方法可以实现这一点.

欢迎任何有关更好架构的参考资料.

我无法在线找到任何在项目中使用gRPC和protobuf的"最佳实践".我正在实现一个事件源服务器端应用程序.核心定义域聚合,事件和服务,而不具有外部依赖性.gRPC服务器调用传递请求对象的核心服务,最终转换为正在发布的事件.事件使用protobuf序列化并在线上发布.我们目前处于两难境地,即我们的事件是否应该是protobuf直接生成的类,还是我们应该将核心和事件分开并实现mapper/serializer层来转换protobuf < - > core之间的事件

如果我们没有考虑另一种方法,请指导我们:)

谢谢您的帮助.

https://github.com/golang/protobuf

protoc-gen-go 是protoc中的插件,它为输入原型定义生成go绑定.

protoc-gen-go还有一个插件框架,它grpc是一个插件插件 https://github.com/golang/protobuf/tree/master/protoc-gen-go/grpc

$ protoc ./helloworld.proto --go_out=plugins=grpc:.

我可以编写自己的插件并将其与grpc插件一起调用吗？

$ protoc ./helloworld.proto --go_out=plugins=grpc+myplugin:.

我是否需要强制将我的插件构建到protoc-gen-go中？如果没有,那么protoc-gen-go将如何找到myplugin？

在我写这篇文章的时候,Play Framework的版本是v2.6.0-M4.由于Netty冲突,框架的v2.5版本难以使用gRPC(请参阅此stackoverflow答案).

我开始研究gRPC和protobufs.已经从Play Framework 2.5> 2.6.0-M4移植了一个项目,以期实际发布.目前我对gRPC的整合有一些疑问.我想知道如何让gRPC服务器与Play Framework很好地协同工作.我知道v2.6切换到Akka HTTP服务器而不是Netty,而我grpc-netty在sbt中使用依赖,所以也许我必须再次将项目切换到Netty(这里是如何).

出于测试目的,我创建了一个快速而脏的GrpcServer.scala类,它启动了一个带有GrpcServer监听的线程.我设法用gRPC 添加ScalaPB并生成/编译我的protobufs.它非常适合与小型测试NodeJS应用程序通信,但我必须独立于主项目启动此服务器应用程序:

private def start(): Unit = {
    server = ServerBuilder.forPort(GrpcServer.port).addService(GreeterGrpc.bindService(new GreeterImpl, executionContext)).build.start
    GrpcServer.logger.info("Server started, listening on " + GrpcServer.port)
    sys.addShutdownHook {
        System.err.println("*** shutting down gRPC server")
        self.stop()
        System.err.println("*** server shut down")
    }
}

在Play Framework中集成gRPC的可能解决方案

现在,对于Play Framework v2.6中的真正集成,我正在寻找建议.这是我可以做的一些事情:

• 在Play Framework启动时创建一个模块并启动gRPC服务器,如此stackoverflow答案中所述.这意味着我们在现有服务器旁边的不同端口上运行gRPC服务器(来自Play Framework 2.6的Akka HTTP服务器)
• 创建Scala命令并使其长时间运行.因此,当我们在服务器上启动应用程序时,我们始终确保启动运行gRPC服务器的命令.
• 在Play Framework v2.6中从Akka HTTP切换到Netty,并将gRPC与现有的Netty服务器紧密集成,以便挂钩到现有的Netty服务器,而不是自己创建服务器.我想要这个解决方案,但不知道如何处理它.它肯定会避免运行两个单独的http堆栈.

有关清洁集成的任何提示/想法都很有帮助,因为除了以前的2.5版本中存在问题之外,没有太多关于Play Framework和gRPC的信息.

我已经阅读了https://github.com/grpc/grpc/blob/master/doc/load-balancing.md上的负载平衡页面,但仍然对后端GRPC之间正确的负载均衡方法感到困惑实例.我们正在部署多个gRPC"微服务"实例,并希望我们的其他gRPC客户端能够在它们之间进行路由.我们将这些作为pods部署在kubernetes(实际上是Google Container Engine)中.

任何人都可以解释在gRPC服务器之间加载平衡gRPC客户端请求的"推荐"方法吗？似乎客户需要了解端点 - 是否不可能利用Container Engine中的内置LoadBalancer来提供帮助？

使用以下Docker Compose文件在虚拟机上安装Drone 0.8 :

version: '2'

services:
  drone-server:
    image: drone/drone:0.8
    ports:
      - 8080:8000
      - 9000:9000
    volumes:
      - /var/lib/drone:/var/lib/drone/
    restart: always
    environment:
      - DATABASE_DRIVER=sqlite3
      - DATABASE_CONFIG=/var/lib/drone/drone.sqlite
      - DRONE_OPEN=true
      - DRONE_ORGS=my-github-org
      - DRONE_ADMIN=my-github-user
      - DRONE_HOST=${DRONE_HOST}
      - DRONE_GITHUB=true
      - DRONE_GITHUB_CLIENT=${DRONE_GITHUB_CLIENT}
      - DRONE_GITHUB_SECRET=${DRONE_GITHUB_SECRET}
      - DRONE_SECRET=${DRONE_SECRET}
      - GIN_MODE=release

  drone-agent:
    image: drone/agent:0.8
    restart: always
    depends_on: [ drone-server ]
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - DRONE_SERVER=drone-server:9000
      - DRONE_SECRET=${DRONE_SECRET}

所有变量值都存储在.env文件中,并正确传递给正在运行的容器.尝试使用私有Github存储库运行构建.当第一次推送到存储库时,构建开始并因以下错误而失败(即构建失败): 然后在单击" 重新启动"按钮后看到另一个屏幕(即构建正在等待):

让以下容器在同一台机器上运行:

root@ci:~# docker ps -a
CONTAINER ID        IMAGE               COMMAND               CREATED             STATUS              PORTS …

我正在使用地理编码器.在所有设备上,代码工作正常,但在Nexus 5手机上,日志中有例外.

我的代码:

override fun fromAddress(address: Address): Observable<Geolocation> {
    val location = geocoder.getFromLocationName("${address.street} ${address.number}, ${address.postcode}, ${address.city}", LOCATIONS_MAX_RESULTS).first()
    return Observable.just(Geolocation(latitude = location.latitude, longitude = location.longitude))
}

我的错误:

java.io.IOException: grpc failed
  at android.location.Geocoder.getFromLocationName(Geocoder.java:178)
  at nl.ah.appienow.data.address.AndroidGeocoder.fromAddress(AndroidGeocoder.kt:20)
  at nl.ah.appienow.address.ValidatePostcode$execute$1.apply(ValidatePostcode.kt:31)
  at nl.ah.appienow.address.ValidatePostcode$execute$1.apply(ValidatePostcode.kt:17)
  at io.reactivex.internal.operators.observable.ObservableFlatMap$MergeObserver.onNext(ObservableFlatMap.java:121)
  at io.reactivex.internal.operators.observable.ObservableMap$MapObserver.onNext(ObservableMap.java:64)
  at retrofit2.adapter.rxjava2.BodyObservable$BodyObserver.onNext(BodyObservable.java:51)
  at retrofit2.adapter.rxjava2.BodyObservable$BodyObserver.onNext(BodyObservable.java:37)
  at retrofit2.adapter.rxjava2.CallExecuteObservable.subscribeActual(CallExecuteObservable.java:43)
  at io.reactivex.Observable.subscribe(Observable.java:10842)
  at retrofit2.adapter.rxjava2.BodyObservable.subscribeActual(BodyObservable.java:34)
  at io.reactivex.Observable.subscribe(Observable.java:10842)
  at io.reactivex.internal.operators.observable.ObservableMap.subscribeActual(ObservableMap.java:33)
  at io.reactivex.Observable.subscribe(Observable.java:10842)
  at io.reactivex.internal.operators.observable.ObservableFlatMap.subscribeActual(ObservableFlatMap.java:55)
  at io.reactivex.Observable.subscribe(Observable.java:10842)
  at io.reactivex.internal.operators.observable.ObservableSubscribeOn$SubscribeTask.run(ObservableSubscribeOn.java:96)
  at io.reactivex.Scheduler$DisposeTask.run(Scheduler.java:452)
  at io.reactivex.internal.schedulers.ScheduledRunnable.run(ScheduledRunnable.java:61)
  at io.reactivex.internal.schedulers.ScheduledRunnable.call(ScheduledRunnable.java:52)
  at java.util.concurrent.FutureTask.run(FutureTask.java:237)
  at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:269)
  at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1113)
  at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:588)
  at …

我最近开始在工作中阅读和使用gRPC.gRPC在内部使用协议缓冲区作为其IDL,我随时随地读取协议缓冲区执行得更好,尤其是与JSON和XML相比更快.

我不明白的是 - 他们是怎么做到的？与XML和JSON相比,协议缓冲区中的哪些设计实际上使它们的执行速度更快？

我正在尝试与不安全的 gRPC 服务器建立连接。我使用 gRPC 在 Docker 容器内的两个进程之间进行通信，这就是为什么我不需要任何加密或强身份验证。

服务器按预期运行，我可以像这样使用 grpcurl 进行调用：

grpcurl -plaintext localhost:42652 SomeService.DoSomething

现在我正在尝试从 .Net Core 应用程序调用相同的 RPC 方法：

// Registration of the DI service
services.AddGrpcClient<DaemonService.DaemonServiceClient>(options => {
    // Enable support for unencrypted HTTP2
    AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);

    options.Address = new Uri("http://localhost:42652");

    // Just a test, doesn't change anything.
    options.ChannelOptionsActions.Add(channelOptions => channelOptions.Credentials = ChannelCredentials.Insecure);
});

// Call
var reply = _someServiceClient.DoSomething(new Request());

但是最后一行中的调用导致异常：

fail: Grpc.Net.Client.Internal.GrpcCall[6]
      Error starting gRPC call.
System.Net.Http.HttpRequestException: An error occurred while sending the request.
 ---> System.IO.IOException: The response …

我正在尝试使用 C++ 实现异步服务器端流。但我找不到任何好的例子。我很难异步读取流。

服务器代码

class ServerImpl final
{
public:
    ~ServerImpl()
    {
        server_->Shutdown();
        cq_->Shutdown();
    }

    void Run()
    {
        std::string server_address("0.0.0.0:50051");

        ServerBuilder builder;
        builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
        builder.RegisterService(&service_);

        cq_ = builder.AddCompletionQueue();
        server_ = builder.BuildAndStart();
        std::cout << "Server listening on " << server_address << std::endl;

        HandleRpcs();
    }

private:
    class CallData
    {
    public:
        CallData(MultiGreeter::AsyncService* service, ServerCompletionQueue* cq)
            : service_(service)
            , cq_(cq)
            , responder_(&ctx_)
            , status_(CREATE)
            , times_(0)
        {
            Proceed();
        }
      void Proceed()
        {
            if (status_ == CREATE)
            {
                status_ = PROCESS;
                service_->RequestsayHello(&ctx_, &request_, &responder_, cq_, cq_, …