Introduction to grpc for cloud native application development

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

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 .

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

• 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

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)
}
}


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)
}
}


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) {}
}

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

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)
}
}


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
}

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 run server.go
Go gRPC Beginners Tutorial!

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)

}


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

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

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 ：

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 .

Reference link ：

• Go gRPC Beginners Tutorial

• 《gRPC  And cloud native application development 》