Go: how to create a gRPC client

  • Go
  • Gabriele Romanato

gRPC is an open-source framework developed by Google that enables efficient and scalable communication between distributed services. Using the HTTP/2 protocol for transport and binary serialization for data, gRPC offers high performance and ease of development in various programming languages, including the Go language. In this article, we will explore how to create a gRPC client in Go step by step by step.

Before you begin, make sure you have Go installed on your system. Next, youll need to install some dependencies needed to create a gRPC server. The main dependency is the Go gRPC package. You can install it using the following command: 

go get -u google.golang.org/grpc

Lets start by defining our gRPC service. Lets create a file called calculator.proto in a folder of your project. The contents of the file might look like this: 


syntax = "proto3";

package calculator;

service CalculatorService {
    rpc Add(AddRequest) returns (AddResponse);
}

message AddRequest {
    int32 num1 = 1;
    int32 num2 = 2;
}

message AddResponse {
    int32 result = 1;
}

After defining the .proto file, we need to generate the corresponding Go files which contain the types and methods of the gRPC service. Open the terminal and navigate to the folder where the .proto file is located. Then run the command: 

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

Now we can start building our gRPC client. Create a file called main.go in your project and add the following code: 


package main

import (
	"context"
	"fmt"
	"log"

	"google.golang.org/grpc"

	"your_project_path/calculator"
)

func main() {
	// Imposta l'indirizzo del server gRPC
	serverAddress := "localhost:50051"

	// Crea una connessione al server
	conn, err := grpc.Dial(serverAddress, grpc.WithInsecure())
	if err != nil {
		log.Fatalf("Impossibile connettersi: %v", err)
	}
	defer conn.Close()

	// Crea un client gRPC
	client := calculator.NewCalculatorServiceClient(conn)

	// Crea una richiesta
	request := &calculator.AddRequest{
		Num1: 10,
		Num2: 20,
	}

	// Chiama il metodo Add sul server
	response, err := client.Add(context.Background(), request)
	if err != nil {
		log.Fatalf("Errore durante la chiamata: %v", err)
	}

	// Stampa la risposta
	fmt.Printf("Risultato: %d\n", response.Result)
}

Now you can run your gRPC client. Make sure the gRPC server is running and has defined the corresponding service. Then in your terminal, run: 

go run main.go

The client should connect to the server, call the Add method and print the result returned by the server.

Conclusion

Creating a gRPC client in Go is a relatively straightforward process once youve defined the service interface and generated the corresponding Go files. gRPC offers an efficient and performant way to communicate between distributed services, and Go provides excellent integration with this technology. Use this step-by-step guide to build your own gRPC clients and experiment with cross-service communication efficiently.

Back to top