[英]How to make a HTTP request from server to client using grpc in golang
[英]GRPC Web Request using golang client?
我正在嘗試使用 grpc-web 包裝器的 hep 創建一個 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\n")
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 function,如下所示。 但它不工作..
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 沒有對 HTTP/2 請求提供足夠的控制來實現 gRPC)。 這篇博文提供了一個很好的概述。
因為您正在構建一個網絡應用程序,所以您需要使用 gRPC-Web; 如果您還希望使用 go 客戶端連接到您的服務器,那么首選選項是使用 gRPC(服務器可以同時使用兩者)。 另一個可行的選擇是使用gRPC-Web 客戶端,但我沒有嘗試過(效率會降低)。
運行 gRPC-Web 的“官方”方式是通過一個特使插件,但是當您在 Go 中編寫此內容時 improbable -eng/grpc-web提供了另一個更簡單的選項,您已經在使用(他們也有一個代理,但這使得部署更復雜)。
您的服務器需要更改以同時運行 gRPC 和 gRPC-Web。 最簡單的選擇是在不同的端口上運行它們(可以使用多路復用器來檢測內容類型,但這不是我嘗試過的;如果你想提供 html/js 和 gRPC-它確實工作得很好- 單個端口上的 Web )。
以下是我運行兩台服務器所采用的方法(請將此視為不完整的偽代碼,我已經從我的一些應用程序中提取了一些信息,但尚未編譯/測試等;當您發現問題時,請隨時更新:):
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
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.