Chapter 1.
Introducing gRPC
__gRPC
____Service Definition
____gRPC server
____gRPC client
____Client-Server Message Flow
__History of interprocess communication
____Existing RPC
____SOAP
____REST
____The Beginning of gRPC
____Why gRPC?
____Comparison with other protocols: GraphQL and Thrift
__gRPC Real-World Case Studies
____Netflix
____etcd
____Dropbox
__summation


Chapter 2.
Getting started with gRPC
__Write a service definition
____Message Definition
____Service Definition
__avatar
____Service Development
____gRPC client development
__Build and Run
____Go Server Build
____Go client build
____Running the Go server and client
____Java Server Build
____Building the Java Client
____Running Java Server and Client
__summation


Chapter 3.
gRPC communication patterns
__Simple RPC (Single RPC)
__Server Streaming RPC
__Client Streaming RPC
__Bidirectional streaming RPC
__gRPC for microservice communication
__summation


Chapter 4.
gRPC: How It Works
__RPC flow
__Message encoding using protocol buffers
____encoding technology
__length-prefixed message framing
gRPC over HTTP/2
____Request Message
____Response message
Understanding message flow in ____gRPC communication patterns
__gRPC implementation architecture
__summation


Chapter 5.
gRPC: Advanced Features
__Interceptor
____Server-side interceptor
____Client-side interceptor
__Deadline
__Cancellation Processing
__Error handling
__multiplexing
__metadata
____Metadata creation and query
____Metadata transmission and reception: Client side
____Metadata transmission and reception: Server side
____Name Resolver
__load balancing
____Load Balancer Proxy
____Client-side load balancing
____compression
__summation


Chapter 6.
Secure gRPC
gRPC channel authentication using __TLS
____Enable one-way secure connection
____Enable mTLS secure connections
__gRPC call authentication
____Use Basic Authentication
____Using OAuth 2.0
Using ____JWT
____Use Google token-based authentication
__summation


Chapter 7.
Running gRPC at the service level
__Testing gRPC applications
____gRPC server testing
____gRPC client testing
____Load Test
____Continuous Integration
__distribution
Deploying to ____Docker
____Deploying to Kubernetes
__Observability
____metric
____log
____tracking
____Debugging and Troubleshooting
____Enable additional logging
__summation


Chapter 8.
gRPC ecosystem
__gRPC Gateway
__HTTP/JSON transcoding for gRPC
__gRPC Server Reflection Protocol
__gRPC middleware
__Status Check Protocol
__gRPC health probe
__Other ecosystem projects
__summation

What this book covers
- Understand the basics of gRPC and compare it to similar technologies.
- Verify gRPC communication patterns through real-world examples
- Internal details of the gRPC communication protocol
- Explore advanced gRPC features like interceptors, multiplexing, and error handling.
- Protect communication channels and authenticate users.
- Testing, CI/CD integration, Docker, and Kubernetes deployment according to the gRPC application lifecycle.


Target audience for this book
This book is for developers building distributed applications and microservices using inter-process communication technologies.
If you're building distributed applications or microservices, you need to learn the basics of gRPC, including when and how to use it for inter-service communication, and best practices for real-world use cases.
Additionally, architects who adopt microservices or cloud-native architectures and design service communication methods can gain a lot of insight because they have to compare them with other technologies and provide guidance on when to use them and when not to use them.

Developers and architects reading this book are assumed to have a basic understanding of distributed computing fundamentals, such as interprocess communication technologies, service-oriented architecture (SOA), and microservices.

Structure of this book
It explains theoretical concepts through real-world application cases, and provides practical experience for each concept through extensive use of code examples using the Go language and Java.
This book is organized into eight chapters as follows:

Chapter 1, "Introducing gRPC," provides a foundational understanding of gRPC fundamentals and compares it to similar interprocess communication technology styles such as REST, GraphQL, and other RPC technologies.

Chapter 2, "Getting Started with gRPC," provides a first look at building a complete gRPC application using the Go language and Java.

Chapter 3, 'gRPC Communication Patterns', examines gRPC communication patterns through real-world examples.

Chapter 4, "gRPC: How It Works," is for advanced users interested in gRPC internals. It explains all the steps of gRPC communication between the server and client and how it works over the network.

Chapter 5, "gRPC: Advanced Features," covers key advanced features such as interceptors, deadlines, metadata multiplexing, and load balancing.

Chapter 6, "Securing gRPC," provides a comprehensive understanding of how to secure communication channels and user authentication and access control for gRPC applications.

Chapter 7, "Running Service-Level gRPC," examines the entire development life cycle of a gRPC application.
Learn about testing gRPC applications, integrating with CI/CD, deploying and running with Docker and Kubernetes, and checking their health.

Chapter 8, "The gRPC Ecosystem," describes useful support elements of gRPC.
Most projects are useful when building real-world applications based on gRPC.

Author's Note
Modern software applications often connect to each other over computer networks using interprocess communication technologies.
gRPC is a modern interprocess communication style based on high-performance Remote Procedure Calls (RPCs) used for building distributed applications or microservices, and its adoption is growing exponentially with the advent of microservices and cloud-native applications.

This book was written because, with the increasing use of gRPC, I felt the need for an in-depth book that could serve as the ultimate reference guide for all stages of the gRPC application development lifecycle.
While there are numerous resources and code samples for gRPC everywhere (documentation, blogs, articles, conference talks, etc.), there is no single resource for developing gRPC applications, nor is there a resource for understanding the internal protocol and how it works.

We aim to overcome these challenges and provide a comprehensive understanding of gRPC fundamentals, how it differs from existing inter-process communication technologies, practical gRPC communication patterns, application development using Go and Java, how it works behind the scenes, running it in real-world environments, and how it interacts with Kubernetes and other ecosystems.


Translator's Note
With the advent of cloud-native and microservice architectures, building and operating container-based systems like Docker has become essential, even fundamental, for enterprises seeking to quickly adapt to rapidly changing business and technological changes.
In addition, polyglot programming and communication technologies between various services are emerging as key technologies for actively utilizing the cloud and microservices.
In particular, gRPC has quickly become an important technology for efficient communication with various languages ​​and systems.

gRPC originated from a software called Stubby, which was used for over a decade to connect thousands of services in Google data centers. Since being open-sourced in 2015, it has been actively used by large services such as Netflix, and continues to evolve with the active support of various open source communities.
In particular, the languages ​​that are currently officially supported include not only traditional languages ​​such as C/C++, C#, Java, Python, and Ruby, but also relatively new languages ​​such as Objective-C, Go, Node.js, Dart, and Kotlin, including various system environments and compilers.


This book not only provides a variety of guides based on real-world examples of basic gRPC usage, but also provides excellent guidance for software architects designing inter-application communication through comparisons with existing communication technologies.
It also provides a comprehensive understanding of communication technologies by providing in-depth explanations of various communication patterns and internal workings, and details the various technical elements that must be considered when applying service levels in practice.
It includes advanced technologies such as authentication, access control, and load balancing for service expansion, and also presents testing, CI/CD integration, and various monitoring technologies required for the development cycle.

We hope this book will serve as a foundation for developing robust applications and microservices using gRPC communication technology.