gRPC in Go: Creating Your First Server

asmanya

3 min read

·

Oct 2, 2025

--

2

Listen

Share

gRPC is a high-performance, open-source framework for remote procedure calls. It uses Protocol Buffers (protobuf) for defining messages and services, making communication between client and server fast and efficient. In this tutorial, we’ll create a Calculator gRPC server in Go that performs addition.

Overview of the Steps

Before diving into the implementation, here’s a brief overview of what we’ll do (the steps are explained below with code):

1. Install prerequisites — Make sure Go is installed, along with the Protocol Buffers compiler (protoc) and the Go gRPC plugins (protoc-gen-go and protoc-gen-go-grpc). These tools generate Go code from .proto files automatically.
2. Create the .proto file — Define the messages (AddRequest and AddResponse) and the Calculate service with the Add RPC method. This file acts as a contract between client and server.
3. Generate Go code — Use the protoc compiler to create Go structs and server interfaces from the .proto file.
4. Implement the server in Go — Create server.go and implement the Add method that receives two numbers and returns their sum.
5. Enable TLS (optional) — Secure the server using TLS certificates. (The cert and key files can be removed if TLS is not enabled, and the necessary changes should be made accordingly.)
6. Run the server — Start the gRPC server and listen on a TCP port for incoming requests.
7. Test the server — Use a gRPC client (or tools like Postman, Evans CLI) to send requests and verify addition works as expected.

Step 1: Install Prerequisites

Before starting, ensure you have:

• Go installed (version 1.20+ recommended)
• Protocol Buffers compiler (protoc)
• Go plugins for gRPC:

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

These plugins generate Go code from your .proto files, so you don’t have to write boilerplate code manually.

Step 2: Create the .proto File

Create a file called calculator.proto:

syntax = "proto3";

package proto;

option go_package = "simplegrpcserver/proto/gen;gen";

// Request message for addition
message AddRequest {
  int32 a = 1;
  int32 b = 2;
}

// Response message with the sum
message AddResponse {
  int32 sum = 1;
}

// Calculator service
service Calculate {
  rpc Add(AddRequest) returns (AddResponse);
}

Explanation:

AddRequest contains the two numbers to add. AddResponse contains the sum. Calculate service defines the Add RPC method. This .proto file is the blueprint for your service.

Step 3: Generate Go Code

Run the protoc compiler to generate Go code:

protoc --go_out=. --go-grpc_out=. proto/calculator.proto

This creates Go structs (AddRequest, AddResponse) and interfaces for the Calculate service in the proto/gen folder.

{Do not edit these generated files manually.}

Step 4: Implement the Server

Create server.go:

package main

import (
 "context"
 "log"
 "net"

 pb "simplegrpcserver/proto/gen"

 "google.golang.org/grpc"
 "google.golang.org/grpc/credentials"
 "google.golang.org/grpc/metadata"
 "google.golang.org/grpc/reflection"
)

// Server implementing the Calculate service
type server struct {
 pb.UnimplementedCalculateServer
}

// Add two numbers and log metadata
func (s *server) Add(ctx context.Context, req *pb.AddRequest) (*pb.AddResponse, error) {
 md, _ := metadata.FromIncomingContext(ctx)
 log.Println("Metadata received:", md)

 sum := req.A + req.B
 return &pb.AddResponse{Sum: sum}, nil
}

func main() {
 port := ":50051"
 cert := "cert.pem"
 key := "key.pem"

 lis, err := net.Listen("tcp", port)
 if err != nil {
  log.Fatal("Failed to listen:", err)
 }

 creds, err := credentials.NewServerTLSFromFile(cert, key)
 if err != nil {
  log.Fatalln("Failed to load TLS credentials:", err)
 }

 grpcServer := grpc.NewServer(grpc.Creds(creds))
 pb.RegisterCalculateServer(grpcServer, &server{})

 reflection.Register(grpcServer)

 log.Printf("Calculator gRPC server is running on port %s...", port)
 if err := grpcServer.Serve(lis); err != nil {
  log.Fatal("Failed to serve:", err)
 }
}

Key points:

• Implements the Add method.
• Logs any metadata sent by the client.
• Registers the service and starts the gRPC server with TLS.

Step 5: Run the Server

Start the server:

go run server.go

Your server now listens on port 50051 and is ready to handle addition requests.

Step 6: Test the Server

You can test using a gRPC client or tools like Postman etc.

You now have a secure, functional Calculator gRPC server in Go!