GRPC 正向代理实现

目录：

1、proto文件2、maven编译的时候同时编译proto文件生成对应的java类3、编写grpc的客户端，编写Grpc服务端，4、proxy的配置 1、proto文件编写

必须定义版本 proto3

syntax = "proto3";

import "google/protobuf/wrappers.proto";
import "google/protobuf/empty.proto";

option java_multiple_files = true;
option java_package = "com.test.grpc.common.pb";
option java_outer_classname = "RpcClient";


message SayHelloPB {
    string request = 1;
}

message SayHelloResponsePB {
   string response = 1;
}

service RpcService {
    rpc sayHello(SayHelloPB) returns (SayHelloResponsePB);
}

maven pom文件中加入：

        
            
                kr.motd.maven
                os-maven-plugin
                1.5.0.Final
            
        

        
            
            
                org.xolstice.maven.plugins
                protobuf-maven-plugin
                0.5.1
                
                    
                        com.google.protobuf:protoc:3.7.1:exe:${os.detected.classifier}
                    
                    grpc-java
                    
                        io.grpc:protoc-gen-grpc-java:1.21.0:exe:${os.detected.classifier}
                    
                
                
                    
                        
                            compile
                            compile-custom
                        
                    
                
            
        
    

客户端编写：

客户端中，定义成员变量，private RpcServiceGrpc.RpcServiceBlockingStub stub，并实例化stub，需要传入Channel，

客户端代码：
主要注意channel 建立中的address包含两个，一个客户端代理的地址，另一个是真正server端的地址。

import java.net.InetSocketAddress;
import java.util.concurrent.TimeUnit;

import com.test.grpc.common.pb.RpcServiceGrpc;
import com.test.grpc.common.pb.SayHelloPB;

import io.grpc.Channel;
import io.grpc.CompressorRegistry;
import io.grpc.HttpConnectProxiedSocketAddress;
import io.grpc.ProxiedSocketAddress;
import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;

public class GrpcClient {
    private RpcServiceGrpc.RpcServiceBlockingStub stub;
    public GrpcClient(String host, int port){
        this.stub = RpcServiceGrpc.newBlockingStub(getChannel(host,port));
    }

    private Channel getChannel(String host, int port) {
        // 正向代理所在的ip 和port. 本地nginx listen的端口号8889
        String proxyHost = "127.0.0.1";
        int proxyPort = 8889;

        final InetSocketAddress proxyAddress =
                new InetSocketAddress(proxyHost, proxyPort);

        // 真正要访问的目的ip和port
        final InetSocketAddress targetServerAddress =
                new InetSocketAddress(host, port);

        ProxiedSocketAddress proxiedSocketAddress =
                HttpConnectProxiedSocketAddress.newBuilder()
                                               .setProxyAddress(proxyAddress)
                                               .setTargetAddress(targetServerAddress)
                                               .build();

        // address 中包含两个地址
        Channel channel1 = NettyChannelBuilder.forAddress(proxiedSocketAddress)
                                              .usePlaintext()
                                              .compressorRegistry(CompressorRegistry.getDefaultInstance())
                                              .idleTimeout(1800, TimeUnit.SECONDS)
                                              .build();

        return channel1;
    }

    // 客户端方法
    public void sayHello(String helloString) {
        SayHelloPB sayHelloPB =
                SayHelloPB.newBuilder()
                          .setRequest("hello~" + helloString)
                          .build();
        System.out.println(stub.sayHello(sayHelloPB).getResponse());
    }
}

核心类：HttpConnectProxiedSocketAddress
查看API文档：

这里指出了我们使用的proxy的类型，当前的这种方式是利用了HTTP CONNECT方法，这种隧道代理方法的介绍参看这里，代理原理和HTTPS的正向代理一样，所以相关资料可以查询https的正向代理。
大致意思是：
我们知道HTTPS是加密通信的，无论是请求体还是请求头都是加密的，代理服务器没有密钥，就无法解密出请求头，那么https的数据报发到代理服务器，代理如何知道当前数据包需要发往哪里呢？

这里可以利用HTTP CONNECT方法，在报文中加一个部分，明文指出我要访问的服务端的地址，这样proxy就不需要解析，直接根据这个明文知道往哪发数据报了。

我认为 curl -x 代理的ip:prot https://baidu.com 这种方式也是用了HTTP CONNECT方法，后续有时间验证下

服务端编写：

需要继承proto编译后生成java类，public class GrpcServer extends RpcServiceGrpc.RpcServiceImplbase， 重写方法，写入自己的server逻辑

服务端代码：

import com.test.grpc.common.pb.RpcServiceGrpc;
import com.test.grpc.common.pb.SayHelloPB;
import com.test.grpc.common.pb.SayHelloResponsePB;

import io.grpc.stub.StreamObserver;

public class GrpcServer extends RpcServiceGrpc.RpcServiceImplbase {
    @Override
    public void sayHello(SayHelloPB request,
                         StreamObserver responseObserver) {
        String requestMessage = request.getRequest();
        String message = "i received the message :" + requestMessage;
        System.out.println(message);
        SayHelloResponsePB responsePB =
                SayHelloResponsePB.newBuilder().setResponse("i am the Moon").build();
        responseObserver.onNext(responsePB);
        responseObserver.onCompleted();
    }
}

采用nginx来做正向代理，其配置和HTTPS的正向代理配置一样，
需要添加第三方模块：ngx_http_proxy_connect_module
github地址
需要下载下来，nginx 中编译配置时加入这个第三方模块。
这里需要的知识是：nginx如何加入第三方模块（分为两种1、在已安装好的nginx中引入，2、在安装nginx时引入第三方模块）
我因为用的docker，所以测试安装nginx成本小，错误后删掉容器重来。
我这里是第二种情况，安装参看我的另一篇博客

nginx.conf:

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       8889; #服务端口号
        server_name  localhost;
	    resolver 114.114.114.114;

	    proxy_connect;
	    proxy_connect_allow all; #允许所有端口号
	    proxy_connect_connect_timeout 60s;
	}
}