Learn gRPC - Pre-Requisites Skill & Setup Environment

#Introduction

Welcome to the Learn gRPC series! This series will help you master gRPC — the modern RPC framework developed by Google, running on top of HTTP/2 with Protocol Buffers as the data format — from conceptual foundations to production readiness. There are 19 episodes in total, organized into six phases.

But before writing your first service, there are a few basic skills and software you need to have. Why do these pre-requisites matter? Because gRPC is not just a library for calling remote functions. It's a communication system that combines protobuf, HTTP/2, streaming, and well-defined service contracts. If you don't yet understand how HTTP/2 works or how protobuf is serialized, debugging connection issues will feel like guessing in the dark.

Episode 0 is your roadmap: we'll make sure your basic skills are in place, set up the protoc compiler, install the gRPC SDK in your language of choice, and do the first verification. Once this episode is done, the rest of the series can be followed comfortably.

#Basic Skills You Must Master

#HTTP/2, RPC, and Client-Server Architecture

Understand these three concepts first, because gRPC uses them every day. RPC (Remote Procedure Call) is the technique of calling a function that runs in another process or machine as if it were local. Client-server architecture means one party initiates communication (the client) while another provides the service (the server). HTTP/2 is the transport protocol gRPC uses: it runs over TCP, keeps connections alive, and allows many streams to run concurrently on a single connection.

If you're not familiar with it yet, try inspecting HTTP/2 traffic with:

curl -I --http2 https://grpc.io

Look at the HTTP/2 200 line in the output. Headers sent via the curl --http2 protocol show that the server supports HTTP/2 — the same transport foundation gRPC uses.

#Data Serialization and Protocol Buffers v3

gRPC does not send data as JSON text. It uses Protocol Buffers (protobuf) version 3, a contract-based binary serialization format. You define data structures in a .proto file, and then protoc generates code in various languages. Two concepts are mandatory:

• Message: a data structure with numbered fields, for example string name = 1.
• Binary encoding: data is sent as compact bytes, not long strings.

These concepts are covered in depth starting from episode 3. For now, just understand that protobuf gives gRPC its speed and small payload sizes.

#Networking Basics, Ports, and TLS

gRPC is a network protocol. You need to be comfortable with the concepts of port (where the server listens, e.g. 50051), address (e.g. localhost:50051), and TLS (transport layer encryption). TLS is covered in full in episode 11, but for now know that gRPC can run plaintext for development and be secured via TLS for production.

#One Programming Language Supported by gRPC

gRPC supports many languages. You only need to master one of them: Go, Node.js, Python, Java, C#, or Rust. This series uses Go for the server examples and Node.js for the client examples, but the principles are the same in every language because the .proto contract is generated automatically.

#Software You Need to Prepare

#The protoc Compiler and Language Plugins

The essential components: the protobuf compiler (protoc) to read .proto files, and language plugins to generate both client and server code. Both will be installed in the next section.

#gRPC SDK / Runtime

Each language has an official runtime. For Go, the main library is google.golang.org/grpc. For Node.js, use @grpc/grpc-js. For Python, grpcio. Pick the one for the language you know, then add it as a project dependency.

#Editor and Docker

Use an editor with protobuf syntax highlighting, such as VS Code with the official extension. Also prepare Docker, because episodes 7 and 17 will run the gRPC server inside containers:

docker --version

The output should show the running Docker version. The system will also need an internet connection to download dependencies when testing across platforms.

#Installing protoc and Language Plugins

#Installing protoc

The most stable approach is to download the official release from GitHub, or use a package manager if its version is new enough:

apt-get update
apt-get install -y protobuf-compiler
protoc --version

The protoc --version command should show a version like libprotoc 3.21.x. For the newest version, download the archive from the official protobuf releases and extract it to /usr/local.

#Language Plugins for Go

For Go, install the two official plugins:

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

Both commands produce the protoc-gen-go and protoc-gen-go-grpc binaries. Make sure the $HOME/go/bin directory is in your PATH by checking:

which protoc-gen-go
which protoc-gen-go-grpc

If which protoc-gen-go returns the binary's location, the plugin installation was successful. For Node.js, there's no separate plugin: just run npm install @grpc/grpc-js.

#Verifying the Environment

Before moving on to episode 1, run a quick verification to make sure everything is ready. Create a new project directory:

mkdir belajar-grpc
cd belajar-grpc
go mod init belajar-grpc

Then make sure all the main components are installed:

protoc --version
go version
docker --version
which grpcurl

The which grpcurl command only needs to return a location if you've installed grpcurl — the CLI tool for calling gRPC services from the terminal that we'll use starting from episode 9. If it's missing, install it via go install github.com/fullstorydev/grpcurl/cmd/grpcurl@latest.

#Pre-Requisites Summary

A recap of the skills and tools you've prepared in episode 0:

• HTTP/2, RPC, and client-server: the communication fundamentals gRPC uses every day.
• Protocol Buffers v3: the contract-based binary serialization format built on .proto.
• Networking basics: ports, addresses, and TLS.
• protoc installed with language plugins such as protoc-gen-go and protoc-gen-go-grpc.
• The gRPC SDK in your language of choice and Docker as preparation for deployment.

If anything is missing, stop and complete it before continuing. A strong foundation will make the next 18 episodes feel much lighter.

#Closing

Key takeaways:

• Master HTTP/2, RPC, and client-server architecture as the foundation of gRPC.
• Protobuf v3 is a contract-based binary format; understand the concepts of message and numbered fields.
• Install protoc and the language plugins for the language you chose.
• Prepare the gRPC SDK, an editor, Docker, and grpcurl for your development workflow.
• Verify the toolchain before starting: protoc --version and go version.

In episode 1 next, we'll discuss the history, background, and why we need gRPC — from the birth of Stubby at Google, the 2015 open source release, the standardization of protobuf as the default IDL, to an in-depth comparison of gRPC versus REST/JSON and when it's best not to use gRPC. Make sure your environment is ready, because the Learn gRPC journey has only just begun!