标签: grpc-java

我想要

• 用Java编写我的后端代码,
• 使用HTTP/2(NGINX 1.9.5已支持HTTP/2),
• 编写双向流,随时在客户端和服务器之间发送数据.

gRPC似乎是最好的选择,我想使用NGINX作为我的反向代理和加载平衡,我找不到任何文档来弄清楚如何将NGINX用于gRPC Java,有谁知道？

我看到gRPC PHP已经支持NGINX:https://github.com/grpc/grpc/tree/master/src/php#use-the-grpc-php-extension-with-nginxphp-fpm

但是我也看到有一个问题说它正在NGINX中提交第三方模块以获得gRPC支持,并且NGINX上有一张票据意味着我们无法为gRPC编写HTTP/2 NGINX代理模块,而我还看到nginx不支持完整的HTTP/2规范,gRPC无法通过它工作

我对此感到困惑,为什么有些帖子说gRPC PHP有效,但在其他帖子中它说它不能.

我正在尝试创建一个java grpc客户端来与go中的服务器通信.我是grpc的新手,所以按照本教程gRPC Java Tutorial.在这些示例中,它们指的是阻塞和非阻塞存根,它们似乎从其github中的其他位置导入.

import io.grpc.examples.routeguide.RouteGuideGrpc.RouteGuideBlockingStub;
import io.grpc.examples.routeguide.RouteGuideGrpc.RouteGuideStub;
...
...    
blockingStub = RouteGuideGrpc.newBlockingStub(channel);
asyncStub = RouteGuideGrpc.newStub(channel);

但是我在他们的回购中找不到这些类.如果在编译.proto文件时它们是否已生成,我仍然对它们的用途感到朦胧？任何帮助/指针将不胜感激.谢谢.

阅读完 HTTP/2 RFC (#7540)和 TLS-ALPN RFC (#7301)后，我仍然无法弄清楚当一端缺少 ALPN 时的预期行为。

假设我有一个使用 HTTP/2“h2”（通过 TLS）的客户端，该客户端与支持 HTTP/2 的服务器通信，但不在“服务器问候”中发送 ALPN 扩展。客户的预期行为是什么？

到目前为止，我见过的大多数客户端都认为服务器不支持 HTTP/2，并将连接降级到 http/1.1，但很少有人忽略（go-gRPC）继续使用 HTTP/2。

如果使用在客户端（“h2”）和服务器（“h2c”）之间执行 SSL 终止的 AWS classic LB，则此场景可能会更加实用。在此示例中，客户端发送值为“h2”的 ALPN 扩展，LB 在没有 ALPN 的情况下执行 SSL 握手（正如其部分所预期的那样），最终 JAVA gRPC 由于 HTTP/1.1 降级而失败。

最近，我正在研究构建 gRPC 客户端-服务器交互。

我写了一个 gRPC 服务：

service SearchService {

    rpc Find (SearchReq) returns (SearchRes);

}  

然后我应该使用存根（另一个java应用程序）在客户端调用它。

这两种类型的存根有什么区别？

SearchServiceGrpc.SearchServiceFutureStub futureStub = SearchServiceGrpc.newFutureStub(channel);

SearchServiceGrpc.SearchServiceBlockingStub blockingStub = SearchServiceGrpc.newBlockingStub(channel);

blockingStub.find(request);- 用于阻止

futureStub.find(request).get();- 为了未来

我了解 Java 中的 Futures 是如何工作的，但我不明白 gRPC 内部发生了什么以及哪种类型的存根调用更有效率

我在谷歌上没有找到关于它的信息。

谢谢！

我有两个使用gRPC进行通信的微服务。两个都是部署在ECS上的Docker应用程序。如何配置它们以使用AWS ALB？在文档中说ALB支持HTTP / 2，但是我只能看到HTTP1设置。我的应用程序在8080处具有一个gRPC端口和一个运行状况检查API。如何在ALB上进行配置？

这是我的场景。grpc 服务器是一个异步服务器，它从其他源订阅数据。它还为其客户端提供了订阅功能，因此一旦从其他来源接收到数据，它就可以将数据推送到 grpc 客户端。服务器是用Java 实现的。

@Override
public StreamObserver<Message> subscribe (
        StreamObserver<Message> responseObserver) {
    return new StreamObserver<Message>() {

        @Override
        public void onNext(Message message) {
            api.subscribe(message.value, Message -> {
                synchronized (responseObserver) {
                    ...
                    ...
                    // get data from other source

                    responseObserver.onNext(Converter.create().toProtobuf(Message.class, data));
                }
            });
        }

        @Override
        public void onError(Throwable t) {
            log.warn("Encountered error in sub", t);
        }

        @Override
        public void onCompleted() {
            responseObserver.onCompleted();
        }
    };
}

我想使用 python 实现 grpc 客户端来订阅该服务器。然而，奇怪的是，Python一旦订阅数据，就立即关闭，而不等待Java服务器的异步返回。然而，Java 客户端可以永远运行并等待来自服务器的异步数据。

原型

message Message{
    string value = 1;
}
service test …

我们需要将Google Proto缓冲时间戳转换为正常日期。在这种情况下，是否可以将Google Proto缓冲区时间戳LocalDate直接转换为Java ？

我有一台使用相互TLS进行加密和身份验证的gRPC服务器。因此，每个连接到该服务器的客户端都提供一个SSL证书，我想拒绝来自公共密钥大小小于2048位的客户端的连接。似乎还没有直接的方法可以做到这一点。

我能够用ServerInterceptor这种方式做到这一点

public class SSLInterceptor implements ServerInterceptor {
    @Override
    public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
        try {
            SSLSession sslSession = call.getAttributes().get(Grpc.TRANSPORT_ATTR_SSL_SESSION);
            RSAPublicKeyImpl pk = (RSAPublicKeyImpl) sslSession.getPeerCertificates()[0].getPublicKey();
            if (pk.getModulus().bitLength() < 2048) {
                // reject call
            }
            // proceed with the call
        } catch (SSLPeerUnverifiedException e) {
            // do something
        }
        ...
    }
}

这是一个不好的方法，因为

1. 在建立连接之后进行验证。
2. 仅当发出请求/调用时才触发验证。
3. 每个调用都涉及额外的验证开销。
4. 如果验证失败，则仅拒绝呼叫，而不拒绝与客户端的连接。

在理想情况下

1. 验证在连接建立阶段完成。（或在客户端和服务器之间的通道创建过程中的某个时间点）
2. 验证失败将阻止创建连接，并且无法建立连接并稍后断开连接。
3. 每个会话仅对客户端进行一次验证，并且在该会话期间进行的所有调用都不会产生任何开销。

我该如何做得更好？

我正在尝试编写一组服务，为外部客户端提供 REST 接口，同时使用 gRPC/protobuf 进行内部服务间通信。Spring Boot 用于帮助提供后台基础设施支持。我大约一周前才开始学习和使用 Google protobuf 和 gRPC。

我已经能够成功地获得更简单的端到端工作处理，但这些返回单个对象（即没有流）。我在进行旨在流式传输响应对象集合的调用时遇到问题。另一件需要注意的事情是，到目前为止我尝试过的所有事情都是 GET 请求。

下面的示例仅显示了我遇到问题的相关部分。

细节：

• 爪哇8
• Spring Boot 2.1.6.RELEASE
• Spring Boot gRPC 启动器 2.5.1.RELEASE ( https://yidongnan.github.io/grpc-spring-boot-starter/ )
• 谷歌 protobuf Java util 3.10.0

Protobuf 定义：

syntax = "proto3";

package experiment;

message BOM {
    PartSpec part_spec = 1;
    string description = 2;
    string category = 3;
}

message PartSpec {
    string part_number = 1;
    string cage_code = 2;
}

service BOMService {
    rpc getBOMList(google.protobuf.Empty) returns (stream BOM) {}
} …

我正在尝试使用 java GRPC 客户端（netty 和 okhttp）连接到 go 服务器。但他们都间歇性地抛出 UNAVAILABLE: io 异常。

这种情况的发生是随机的，我们不知道是什么导致了这种行为。我们发现请求没有到达go服务器。

用于连接的阻塞存根类似于：

public SomeServiceGrpc.SomeServiceBlockingStub getBlockingStub() {

        ManagedChannel channel = OkHttpChannelBuilder
                .forAddress(configuration.getHost(), configuration.getPort())
                .useTransportSecurity()
                .keepAliveTime(1, TimeUnit.MINUTES)
                .keepAliveTimeout(5, TimeUnit.SECONDS)
                .intercept(deadlineInterceptor)
                .build();
        return SomeServiceGrpc.newBlockingStub(channel);
    }

这些是用于 okhttp 和 protobuf 的库：

    compile 'io.grpc:grpc-okhttp:1.21.0'
    compile 'io.grpc:grpc-protobuf:1.20.0'
    compile 'io.grpc:grpc-stub:1.20.0'

这些是用于 netty 和 protobuf 的库：

    compile group: 'io.grpc', name: 'grpc-netty', version: '1.22.1'
    compile group: 'io.netty', name: 'netty-handler', version: '4.1.35.Final'
    compile group: 'io.netty', name: 'netty-tcnative-boringssl-static', version: '2.0.25.Final'
    compile 'io.grpc:grpc-protobuf:1.20.0'
    compile 'io.grpc:grpc-stub:1.20.0'

任何帮助或领导表示赞赏。