使用Golang客户端的GRPC Web请求？ [英] GRPC Web Request using golang client?

问题描述

我正在尝试使用GRPC-Web Wrapper创建一个GRPC服务器。我们的想法是将这个GRPC服务器既用于基于浏览器的应用程序，也用于普通的GRPC客户端。但我感到困惑的是，我如何才能使其同时适用于这两个应用程序？

package main

import (
    "context"
    "fmt"
    "io"
    "log"
    "net/http"
    "strconv"
    "time"

    "github.com/repo/test-grpc-server/greet/greetpb"
    "github.com/improbable-eng/grpc-web/go/grpcweb"
    "google.golang.org/grpc"
)

type server struct{}

func (*server) Greet(ctx context.Context, req *greetpb.GreetRequest) (*greetpb.GreetResponse, error) {
    fmt.Printf("Greet function was invoked with %v", req)
    firstName := req.GetGreeting().GetFirstName()
    result := "Hello " + firstName
    res := greetpb.GreetResponse{
        Result: result,
    }
    return &res, nil
}

func (*server) GreetManyTimes(req *greetpb.GreetManyTimesRequest, stream greetpb.GreetService_GreetManyTimesServer) error {
    fmt.Printf("GreetMany function was invoked with %v", req)

    firstName := req.GetGreeting().GetFirstName()

    for i := 0; i < 10; i++ {
        result := "Hello " + firstName + " number " + strconv.Itoa(i)
        res := &greetpb.GreetManyTimesResponse{
            Result: result,
        }
        stream.Send(res)
        time.Sleep(1000 * time.Millisecond)
    }
    return nil

}
func (*server) LongGreet(stream greetpb.GreetService_LongGreetServer) error {
    fmt.Printf("LongGreet function was invoked with a streaming request
")
    result := ""
    for {
        req, err := stream.Recv()
        if err == io.EOF {
            // we have finished reading the client stream
            return stream.SendAndClose(&greetpb.LongGreetResponse{
                Result: result,
            })
        }
        if err != nil {
            log.Fatalf("Error while reading client stream: %v", err)
        }

        firstName := req.GetGreeting().GetFirstName()
        result += "Hello " + firstName + "! "
    }
}



func main() {
    fmt.Println("Go gRPC Server")
    /*lis, err := net.Listen("tcp", ":5051")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }*/
    grpcServer := grpc.NewServer()
    greetpb.RegisterGreetServiceServer(grpcServer, &server{})
    grpc := grpcweb.WrapServer(grpcServer)
    http.HandleFunc("/", func(resp http.ResponseWriter, req *http.Request) {
        allowCors(resp, req)
        if grpc.IsGrpcWebRequest(req) || grpc.IsAcceptableGrpcCorsRequest(req) {
            grpc.ServeHTTP(resp, req)
        }
    })
    httpPort := ":50051"
    fmt.Println("HTTP server listening on", httpPort)
    err := http.ListenAndServe(httpPort, nil)
    if err != nil {
        log.Fatal("Failed to start a HTTP server:", err)
    }

}

func allowCors(resp http.ResponseWriter, req *http.Request) {
    resp.Header().Set("Access-Control-Allow-Origin", "*")
    resp.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE")
    resp.Header().Set("Access-Control-Expose-Headers", "grpc-status, grpc-message")
    resp.Header().Set("Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, XMLHttpRequest, x-user-agent, x-grpc-web, grpc-status, grpc-message")
}

现在，我尝试从我的客户端调用GRPC函数，如下所示。但它不起作用..

package main

import (
    "context"
    "fmt"
    "io"
    "log"
    "time"

    "github.com/repo/test-grpc-server/greet/greetpb"
    "github.com/repo/test-grpc-server/sum/sumpb"
    "google.golang.org/grpc"
)

func main() {

    fmt.Println("Hello I'm a client")
    conn, err := grpc.Dial("0.0.0.0:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("could not connect: %v", err)
    }
    defer conn.Close()

    c := greetpb.NewGreetServiceClient(conn)

    doUnary(c)
}
func doUnary(c greetpb.GreetServiceClient) {
    fmt.Println("do unary from the client")
    req := &greetpb.GreetRequest{
        Greeting: &greetpb.Greeting{
            FirstName: "Hsn",
            LastName:  "Hrn",
        },
    }
    res, err := c.Greet(context.Background(), req)
    if err != nil {
        log.Fatalf("error while calling Greet RPC: %v", err)
    }
    log.Printf("Response from Greet: %v", res.Result)

}

我的.prot文件如下所示..

syntax = "proto3";

package greet;
option go_package="./greet/greetpb";

message Greeting {
    string first_name =1 ;
    string last_name = 2;
}

message GreetRequest {
    Greeting greeting = 1;
}

message GreetResponse {
    string result = 1;
}

message GreetManyTimesRequest{
    Greeting greeting =1;
}

message GreetManyTimesResponse{
    string result=1;
}
message LongGreetRequest {
    Greeting greeting = 1;


}

message LongGreetResponse{
    string result = 1;
}


service GreetService{
    //Unary
    rpc Greet (GreetRequest) returns (GreetResponse) {};
    //Server Streaming 
    rpc GreetManyTimes(GreetManyTimesRequest) returns (stream GreetManyTimesResponse) {};
    //Client Streaming 
    rpc LongGreet(stream LongGreetRequest) returns (LongGreetResponse) {};

}

我得到的错误日志是..

Hello I'm a client
INFO: 2021/04/27 12:53:17 [core] parsed scheme: ""
INFO: 2021/04/27 12:53:17 [core] scheme "" not registered, fallback to default scheme
INFO: 2021/04/27 12:53:17 [core] ccResolverWrapper: sending update to cc: {[{0.0.0.0:50051  <nil> 0 <nil>}] <nil> <nil>}
INFO: 2021/04/27 12:53:17 [core] ClientConn switching balancer to "pick_first"
INFO: 2021/04/27 12:53:17 [core] Channel switches to new LB policy "pick_first"
INFO: 2021/04/27 12:53:17 [core] Subchannel Connectivity change to CONNECTING
INFO: 2021/04/27 12:53:17 [core] parsed scheme: ""
INFO: 2021/04/27 12:53:17 [core] scheme "" not registered, fallback to default scheme
INFO: 2021/04/27 12:53:17 [core] ccResolverWrapper: sending update to cc: {[{0.0.0.0:50051  <nil> 0 <nil>}] <nil> <nil>}
INFO: 2021/04/27 12:53:17 [core] ClientConn switching balancer to "pick_first"
INFO: 2021/04/27 12:53:17 [core] Channel switches to new LB policy "pick_first"
INFO: 2021/04/27 12:53:17 [core] Subchannel Connectivity change to CONNECTING
do unary from the client
INFO: 2021/04/27 12:53:17 [core] blockingPicker: the picked transport is not ready, loop back to repick
INFO: 2021/04/27 12:53:17 [core] Subchannel picks a new address "0.0.0.0:50051" to connect
INFO: 2021/04/27 12:53:17 [core] pickfirstBalancer: UpdateSubConnState: 0xc000021cd0, {CONNECTING <nil>}
INFO: 2021/04/27 12:53:17 [core] Channel Connectivity change to CONNECTING
INFO: 2021/04/27 12:53:17 [core] Subchannel picks a new address "0.0.0.0:50051" to connect
INFO: 2021/04/27 12:53:17 [core] pickfirstBalancer: UpdateSubConnState: 0xc000021ed0, {CONNECTING <nil>}
INFO: 2021/04/27 12:53:17 [core] Channel Connectivity change to CONNECTING
INFO: 2021/04/27 12:53:17 [core] Subchannel Connectivity change to TRANSIENT_FAILURE
INFO: 2021/04/27 12:53:17 [transport] transport: loopyWriter.run returning. connection error: desc = "transport is closing"
INFO: 2021/04/27 12:53:17 [transport] transport: loopyWriter.run returning. connection error: desc = "transport is closing"
INFO: 2021/04/27 12:53:17 [core] Subchannel Connectivity change to TRANSIENT_FAILURE
INFO: 2021/04/27 12:53:17 [core] pickfirstBalancer: UpdateSubConnState: 0xc000021ed0, {TRANSIENT_FAILURE connection closed}
INFO: 2021/04/27 12:53:17 [core] Channel Connectivity change to TRANSIENT_FAILURE
INFO: 2021/04/27 12:53:17 [core] pickfirstBalancer: UpdateSubConnState: 0xc000021cd0, {TRANSIENT_FAILURE connection closed}
INFO: 2021/04/27 12:53:17 [core] Channel Connectivity change to TRANSIENT_FAILURE
2021/04/27 12:53:17 error while calling Greet RPC: rpc error: code = Unavailable desc = connection closed
exit status 1

如果有人帮忙，我们将不胜感激。谢谢！

GRPC

根据评论，问题是您试图使用推荐答案客户端连接到GRPC-Web服务器。GRPC和GRPC-Web是不同的有线协议(之所以创建GRPC-Web，是因为Web浏览器API不能对实现GRPC的HTTP/2请求提供足够的控制)。This blog post提供了一个很好的概述。

因为您正在构建一个Web应用程序，所以您需要使用GRPC-Web；如果您还希望使用Go客户端连接到您的服务器，则首选选项是使用GRPC(服务器可以同时使用两者)。另一个可行的方法是使用gRPC-Web client，但我还没有尝试过(它的效率会较低)。

运行GRPC-Web的"官方"方式是通过envoy plugin，但正如您在Go中编写的那样，improbable-eng/grpc-web提供了另一个您已经在使用的更简单的选项(它们也有代理，但这会使部署更加复杂)。

您的服务器需要更改为同时运行GRPC和GRPC-Web。最简单的选择是在不同的端口上运行它们(可能可以使用多路复用器来检测内容类型，但这不是我尝试过的方法；如果您想serve html/js and gRPC-Web on a single port，它确实工作得很好)。

我运行这两个服务器的方法如下(请将其视为不完整的伪代码，我已经从我的几个应用程序中提取了一些代码，但尚未编译/测试等；如果您发现问题，请随时更新！)：

grpcServer := grpc.NewServer()
greetpb.RegisterGreetServiceServer(grpcServer, &server{})

// Your application is probably doing other things and you will want to be
// able to shutdown cleanly; passing in a context is a good method..
ctx, cancel = context.Cancel(context.Background())
defer cancel()   // Ensure cancel function is called eventually

// Start the grpc server on port 50050
grpcTerminated := make(chan struct{})
lis, err := net.Listen("tcp", ":50050")
if err != nil {
    panic(fmt.Sprintf("gRPC - failed to listen: %s", err))
}

go func() {
    if sErr := grpcServer.Serve(lis); sErr != nil {
       fmt.Printf("grpc server shutdown: %s", err)       
    }
    close(grpcTerminated) // In case server is terminated without us requesting this
}()

// Start the grpc-Web server on port 5051
grpcWebTerminated := make(chan struct{})
grpc := grpcweb.WrapServer(grpcServer)
mux := http.NewServeMux()
mux.HandleFunc("/", func(resp http.ResponseWriter, req *http.Request) {
   allowCors(resp, req)
   if grpc.IsGrpcWebRequest(req) || grpc.IsAcceptableGrpcCorsRequest(req) {
      grpc.ServeHTTP(resp, req)
    }
}))
rpcWebServer := &http.Server{
        Handler: mux,
        Addr:    ":50051"}

wg.Add(1)
go func() {
   defer wg.Done()
   if err := rpcWebServer.ListenAndServe(); err != nil {
      fmt.Printf("Web server (GRPC) shutdown: %s", err)
   }
   close(grpcWebTerminated) // In case server is terminated without us requesting this
}()

// Wait for the web server to shutdown OR the context to be cancelled...
select {
   case <-ctx.Done():
      // Shutdown the servers (there are shutdown commands to request this)
   case <-grpcTerminated:
      // You may want to exit if this happens (will be due to unexpected error)
   case <-grpcWebTerminated:
      // You may want to exit if this happens (will be due to unexpected error)
}

// Wait for the goRoutines to complete
<-grpcTerminated:
<-grpcWebTerminated

这篇关于使用Golang客户端的GRPC Web请求？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！