Bastian Eicher

Designing gRPC APIs - The things they don't tell you

What if you could evolve gRPC APIs without ever creating a v2? Learn an evergreen strategy for painless, backward-compatible updates.

Designing gRPC APIs - The things they don't tell you
#1about 2 minutes

Combining resource-oriented design with RPC in gRPC

gRPC uses remote procedure calls, but adopting a resource-oriented design philosophy improves API consistency and predictability.

#2about 5 minutes

Choosing a repository structure for your gRPC project

Evaluate different repository strategies, such as a dedicated proto repo or a monorepo, to manage API definitions and generated code effectively.

#3about 2 minutes

Using linters to enforce API design consistency

Use a linter like Buff to enforce consistent API design rules, but understand the rationale behind warnings to know when they can be safely ignored.

#4about 2 minutes

Understanding the wire format to avoid breaking changes

The gRPC wire format uses integer keys instead of message names, which allows for evolving message types without causing a breaking change for older clients.

#5about 5 minutes

Evolving an API without versioning using a fallback pattern

Instead of versioning, evolve an API by deprecating old methods and adding new ones, while clients use a try-catch fallback to handle older server versions gracefully.

#6about 2 minutes

Handling optional fields and nullable types in Protobuf

Be aware that the `optional` keyword and wrapper types for nullability behave differently across programming languages, affecting client-side code.

#7about 3 minutes

Using the richer error model for detailed error handling

Move beyond simple status codes by using the richer error model to send structured, machine-readable error details in a backward-compatible way.

#8about 2 minutes

Implementing authentication in gRPC services

Leverage existing web framework authentication mechanisms or pre-shared keys, and ensure unauthenticated responses include the correct gRPC headers to be compliant.

Related jobs
Jobs that call for the skills explored in this talk.

Matching moments

An overview of gRPC fundamentals and its trade-offs
04:29 MIN

An overview of gRPC fundamentals and its trade-offs

gRPC Load Balancing Deep Dive

Exploring gRPC for high-performance communication
02:46 MIN

Exploring gRPC for high-performance communication

REST in Peace? What does the API protocol of the future look like? Or do we have it already?

Choosing the right API protocol for today's needs
01:08 MIN

Choosing the right API protocol for today's needs

REST in Peace? What does the API protocol of the future look like? Or do we have it already?

Tracing the evolution of APIs from RPC to GraphQL
02:52 MIN

Tracing the evolution of APIs from RPC to GraphQL

The Great API Debate: REST, GraphQL, or gRPC?

Architectural differences between REST, GraphQL, and gRPC
02:21 MIN

Architectural differences between REST, GraphQL, and gRPC

The Great API Debate: REST, GraphQL, or gRPC?

Designing APIs for trust and backward compatibility
02:43 MIN

Designing APIs for trust and backward compatibility

API‑First: How Twilio Designs for Developers - Justin Kitagawa (Twilio)

Q&A: GraphQL bombs and gRPC for microservices
01:31 MIN

Q&A: GraphQL bombs and gRPC for microservices

The Great API Debate: REST, GraphQL, or gRPC?

Exploring alternatives to REST like gRPC and GraphQL
02:07 MIN

Exploring alternatives to REST like gRPC and GraphQL

API = Some REST and HTTP, right? RIGHT?!

Featured Partners

Related Videos

See all videos
Awful APIs: A History Lesson in Industry Mistakes and Mishaps28:55

Awful APIs: A History Lesson in Industry Mistakes and Mishaps

James Seconde

Evolving your APIs, a step-by-step approach28:49

Evolving your APIs, a step-by-step approach

Nicolas Fränkel

tRPC: API schemas are pure overhead27:00

tRPC: API schemas are pure overhead

Giorgio Boa

Micro-frontends anti-patterns40:17

Micro-frontends anti-patterns

Luca Mezzalira

The Rise of Reactive Microservices46:24

The Rise of Reactive Microservices

David Leitner

Rethinking Reactive Architectures with GraphQL 41:06

Rethinking Reactive Architectures with GraphQL

David Leitner

Seven Myths, Three Reasons, One Goal46:48

Seven Myths, Three Reasons, One Goal

Stefan Priebsch

The Great API Debate: REST, GraphQL, or gRPC?28:16

The Great API Debate: REST, GraphQL, or gRPC?

Alexis Yushin

Related Articles

View all articles
DC
Daniel Cranney
Why Attend a Developer Event?
Modern software engineering moves too fast for documentation alone. Attending a world-class event is about shifting from tactical execution to strategic leadership. Skill Diversification: Break out of your specific tech stack to see how the industry...
Why Attend a Developer Event?

From learning to earning

Jobs that call for the skills explored in this talk.