How do you write a Golang server using gRPC
from scratch? Heres how to do it.
Introduction
Before we begin, I’d like to mention that the code below was taken from the /example
folder in the gRPC
package.
As a textile learner, I like to write things out even if provided - I don’t feel confident being handed code and be expected to learn - I learn better by writing it from scratch; as a result, the gRPC
documentation has not been good to me, to remedy this issue, I’ve written this article to help me understand better by writing out the steps from scratch.
Instructions
Let’s begin by going to our golang
home directory.
$ cd ~/go/src/github.com/bartmika
Create our project and initialize our module.
$ mkdir simple-grpc
$ cd simple-grpc
$ go mod init github.com/bartmika/simple-grpc
Get our project dependencies
$ export GO111MODULE=on # Enable module mode
$ go get google.golang.org/protobuf/cmd/protoc-gen-go
$ go get google.golang.org/grpc/cmd/protoc-gen-go-grpc
Before we begin, make sure we export our path (if you haven’t done this before).
$ export PATH="$PATH:$(go env GOPATH)/bin"
To get started with gRPC
we will need to setup our proto
file. The file is responsible for defining the interface of our project. Proto is a short form for protocol buffers - Would you like to know more?
$ mkdir proto
$ vi proto/greeter.proto
Copy and paste the following code into the file you have open.
syntax = "proto3";
option go_package = "github.com/bartmika/simple-server"; // Don't forget to change!
package helloworld;
// The greeting service definition.
service Greeter {
// Sends a greeting
rpc SayHello (HelloRequest) returns (HelloReply) {}
}
// The request message containing the user's name.
message HelloRequest {
string name = 1;
}
// The response message containing the greetings
message HelloReply {
string message = 1;
}
Now that we defined our interface, we’ll need to generate our client and server files.
$ protoc --go_out=. --go_opt=paths=source_relative \
--go-grpc_out=. --go-grpc_opt=paths=source_relative \
proto/greeter.proto
We have our server and client code generated. We can now write our own golang
code to utilize them. Start by creating our server.
$ mkdir -p cmd/server
$ touch cmd/server/main.go
Copy and paste the following code into our server:
package main
import (
"context"
"log"
"net"
"google.golang.org/grpc"
pb "github.com/bartmika/simple-grpc/proto"
)
const (
port = ":50051"
)
// server is used to implement helloworld.GreeterServer.
type server struct {
pb.UnimplementedGreeterServer
}
// SayHello implements helloworld.GreeterServer
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
log.Printf("Received: %v", in.GetName())
return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}
func main() {
lis, err := net.Listen("tcp", port)
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
pb.RegisterGreeterServer(s, &server{})
if err := s.Serve(lis); err != nil {
log.Fatalf("failed to serve: %v", err)
}
}
Next create our client file.
$ mkdir -p cmd/client
$ touch cmd/client/main.go
Copy and paste the following code into our server:
package main
import (
"context"
"log"
"os"
"time"
"google.golang.org/grpc"
pb "github.com/bartmika/simple-grpc/proto"
)
const (
address = "localhost:50051"
defaultName = "world"
)
func main() {
// Set up a connection to the server.
conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := pb.NewGreeterClient(conn)
// Contact the server and print out its response.
name := defaultName
if len(os.Args) > 1 {
name = os.Args[1]
}
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
if err != nil {
log.Fatalf("could not greet: %v", err)
}
log.Printf("Greeting: %s", r.GetMessage())
}
Finally, run the server and client in seperate terminals via the commands:
$ go run cmd/server
$ go run cmd/client "Bart"
See also
- How to Containerize a Golang App With Docker for Development and Production
- How to Write a Golang App Remotely on a Raspberry Pi Using Atom
- How to Perform RSA Encryption in Javascript (React.js) and Golang
- Quickstart to Building Golang Apps using IPFS
- Docker Learning Resources for Absolute Beginners Programming With Golang