当前位置：网站首页>Introduction to grpc for cloud native application development

Introduction to grpc for cloud native application development

2022-07-08 02:04:00 【51CTO】

gRPC is a modern, open source remote procedure call (RPC) framework that can run anywhere.

Cloud native application development gRPC introduction _golang

What is? gRPC

gRPC Developed by Google , It's a language neutral 、 Platform neutrality 、 Open source remote call procedure .

What is a remote call procedure ？ The simple understanding is to expose the methods that local applications call to other applications .gRPC Is an interprocess communication technology , Can be used to connect 、 call 、 Operate and tune distributed heterogeneous applications . Also like RPC The characteristics of the application are the same ： Just like calling a local function .

Cloud native application development gRPC introduction _ client _02

characteristic

gRPC It's a high performance 、 Open source and generic RPC frame , Facing mobile and HTTP/2 Design , Bring about things like two-way flow 、 Flow control 、 The head of compression 、 single TCP Multiple reuse requests on the connection . These features make it better on mobile devices , More power and space saving .
stay gRPC The client application can directly call the method of the server application on a different machine just like calling the local object , Make it easier for you to create distributed applications and services .
gRPC By default protocol buffers, This is a Google A set of mature structure data serialization mechanism of open source , Its function and XML、json similar , But it is in binary format , Good performance 、 Efficient （ shortcoming ： Poor readability ）.

gRPC and REST difference

It is similar to REST API signal communication , Through it , You can effectively expose the functions in the application to use HTTP Connect to other applications as communication media .

although REST and gRPC A bit similar , But you should note that there are differences in the way they work ：

gRPC Use HTTP/2 agreement , and REST Use HTTP 1.1
gRPC Use protocol buffer data format , Not usually in REST API Standards used in JSON data format
Use gRPC, You can use HTTP/2 function , For example, server-side streaming 、 Client streaming or even two-way streaming .

Go Build a gRPC The server

We started at Go Define a very simple gRPC The server starts . Once we have a simple server up and running , We can start to create an interactive gRPC client .

gRPC Microservices can be implemented , Split a large project into several small and independent business modules , That is service , Efficient communication between services protobuf Agreement to proceed RPC call ,gRPC By default protocol buffers , This is a google A set of mature structure data serialization mechanism of open source （ Of course, other data formats such as JSON ）. It can be used proto files establish gRPC service , use message Type to define method parameters and return types

install golang Of proto tool kit ：

       
       go get -u github.com/golang/protobuf/proto
      
1.

At the beginning of establishing gRPC Before , Make sure it is installed Protocol Buffers v3：

go get -u github.com/golang/protobuf/protoc-gen-go

stay Go Install in gRPC：

       
       go get google.golang.org/grpc
      
1.

Then write a server , By monitoring TCP Port of connection . As follows main function ：

       
       package main
       
 import
       
   "log"
       
   "net"
       
 )
       
 func main() {
       
   lis, err := net.Listen("tcp", ":8000")
       
   if err != nil
       
     log.Fatalf("Fail to listen: %v", err)
       
   }
       
 }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

Next , We need to golang.org Import official gRPC package , So that we can create a new gRPC The server , Then register the endpoint we want to expose , Then through the existing..., which we defined above TCP Connect to provide services ：

       
       package main
       
 import
       
   "log"
       
   "net"
       
   "google.golang.org/grpc"
       
 )
       
 func main() {
       
   lis, err := net.Listen("tcp", ":8000")
       
   if err != nil
       
     log.Fatalf("Fail to listen: %v", err)
       
   }
       
   grpcServer := grpc.NewServer()
       
   if err := grpcServer.Serve(lis); err != nil
       
     log.Fatalf("Fail to serve: %v", err)
       
   }
       
 }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

This is the use of go The most basic preparation gRPC The server , Now the function is still very limited .

Add some features

Then write a client to interact with the previous server , Create a client.proto file ：

       
       syntax = "proto3"; //  Agreement for proto3
       
 package chat;
       
 //  Define send request information 
       
 message Message
       
   //  Define the parameters to send 
       
 //  Parameter type   Parameter name   Identification number ( Do not repeat )
       
 string body = 1;
       
 }
       
 //  Define our services （ Multiple services can be defined , Each service can define multiple interfaces ）
       
 service ChatService
       
 rpc SayHello(Message) returns (Message) {}
       
 }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

This .proto The document discloses our ChatService, It has a separate SayHello function , It can be written by anyone in any language gRPC Client calls .

these .proto Definitions are usually shared between clients of various shapes and sizes , So that they can generate their own code to interact with our gRPC Server communication .

Let's use protoc Tool generation Go specific gRPC Code ：

       
       $ protoc --go_out=plugins=grpc:chat chat.proto
      
1.

You will see that this will generate a chat/chat.pb.go file , This file will contain the generated code , So that we can easily call . Let's update our server.go To register our ChatService, As shown below ：

       
       package main
       
 import
       
   "fmt"
       
   "log"
       
   "net"
       
   "github.com/tutorialedge/go-grpc-beginners-tutorial/chat"
       
   "google.golang.org/grpc"
       
 )
       
 func main() {
       
   fmt.Println("Go gRPC Beginners Tutorial!")
       
   lis, err := net.Listen("tcp", fmt.Sprintf(":%d", 9000))
       
   if err != nil
       
     log.Fatalf("failed to listen: %v", err)
       
   }
       
   s := chat.Server{}
       
   grpcServer := grpc.NewServer()
       
   chat.RegisterChatServiceServer(grpcServer, &s)
       
   if err := grpcServer.Serve(lis); err != nil
       
     log.Fatalf("failed to serve: %s", err)
       
   }
       
 }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.

Then we will have to define SayHello Method , This method will receive a message , Read the body of the message , Then return its own message ：

       
       package chat
       
 import
       
   "log"
       
   "golang.org/x/net/context"
       
 )
       
 type Server struct
       
 }
       
 func (s *Server) SayHello(ctx context.Context, in *Message) (*Message, error) {
       
   log.Printf("Receive message body from client: %s", in.Body)
       
   return &Message{Body: "Hello From the Server!"}, nil
       
 }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

If we want to work for our gRPC The server defines more advanced functions , Then we can define a based on us Server A new method of structure construction , Then add the name of the function to our chat.proto In file , So that our application can expose it as something else gRPC The client can access .

After these final changes , Let's try running our server ：

       
       $ go
       
 Go gRPC Beginners Tutorial!
      
1.
2.

breathtaking ！ We are now on our machine localhost:8000 A brand new 、 Shiny new gRPC The server ！

stay Go Build gRPC client

Now our server is up and running , Let's see how to build a simple client that can interact with it . Update client.go file ：

       
       package main
       
 import
       
   "log"
       
   "golang.org/x/net/context"
       
   "google.golang.org/grpc"
       
   "github.com/tutorialedge/go-grpc-beginners-tutorial/chat"
       
 )
       
 func main() {
       
   var conn *grpc.ClientConn
       
   conn, err := grpc.Dial(":8000", grpc.WithInsecure())
       
   if err != nil
       
     log.Fatalf("did not connect: %s", err)
       
   }
       
   defer conn.Close()
       
   c := chat.NewChatServiceClient(conn)
       
   response, err := c.SayHello(context.Background(), &chat.Message{Body: "Hello From Client!"})
       
   if err != nil
       
     log.Fatalf("Error when calling SayHello: %s", err)
       
   }
       
   log.Printf("Response from server: %s", response.Body)
       
 }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.

When we run it , We should see that our client received a very good message from the server Hello news , As shown below ：

       
       $ go
       
 2022/07/07 23:23:01 Response from server: Hello From the Server!
      
1.
2.

We have successfully created a very simple gRPC client , It can now work with our new gRPC Server communication ！

Installation problems

If you encounter go get google.golang.org/grpc Installation error , as follows ：

Cloud native application development gRPC introduction _ client _03

Replace ：

git clone https://github.com/grpc/grpc-go.git $GOPATH/src/google.golang.org/grpc
git clone https://github.com/golang/net.git $GOPATH/src/golang.org/x/net
git clone https://github.com/golang/text.git $GOPATH/src/golang.org/x/text
go get -u github.com/golang/protobuf/{proto,protoc-gen-go}
git clone https://github.com/google/go-genproto.git $GOPATH/src/google.golang.org/genproto
cd $GOPATH/src/
go install google.golang.org/grpc

summary

Through this article, we have learned how to Go Build a simple gRPC Client and server . We built a basic server , It accepts incoming messages from clients , Then return the response to these clients .