gRPC Conf 2020

As of today we are running about 100 microservices at Wantedly, built with Ruby, Go, Python, Node, and Rust on our production Kubernetes cluster. While we’ve been historically using HTTP/1.1 for majority of inter microservices process communication, since the last year we have started introducing gRPC for some of our microservices which requires low latency and high throughput.

This talk will cover the details of our migration approach and the performance improvement we’ve achieved as a result. Average latency got decreased by 50%, and 90%tile latency was decreased to a seventh. We will discuss our migration steps we’ve took, technical and organizational challenges we’ve faced during the migration, and also tools and libraries we’ve made in order for smooth transitions for servers originally built with Ruby on Rails.

gRPC works perfectly for service-to-service communication in private networks, where a client talks to a server via a direct TCP connection. Things are more complicated if services, users, or CLI tools talk to gRPC servers exposed on the internet, as many of the commonly used application-level load balancers/reverse proxies only support gRPC with additional configuration (e.g., nginx) or not at all (e.g., AWS ELB).
In this session, an approach for communicating with gRPC services through reverse proxies that only support HTTP/1.1 is presented. While the approach comes with some restrictions, it requires next to no changes to both the client and server code, no additional components to be deployed, and ensures maximum compatibility between different client and server setups. Along with the approach, a Go library implementing it will be introduced, demonstrating via code examples and a live demo how this technique can be used as a drop-in replacement in existing Go-based gRPC code.

What's worse than having to deploy ten microservices? Having to deploy ten microservices at exactly the same time. When every change is a breaking API change, every deploy is a lockstep deploy.

In this talk we explore techniques and best practices for evolving protobuf contracts without breaking downstream callers. We start by looking at what constitutes a breaking change, and then explore tactical ways to avoid breaking the service contract. Finally, we will dive into proto design patterns that can minimize the need to break our API contracts.

Apply the techniques in this talk and never worry about breaking your downstream API callers again.

Introducing the gRPC-Gateway, which makes it possible to expose a JSON/REST interface while maintaining many of the benefits of using gRPC.

The first 10 or so minutes will be spent laying the technical ground for the talk by talking about JSON/REST, giving a quick intro into gRPC and [protocol buffers](https://developers.google.com/protocol-buffers/), then introducing the gRPC-Gateway as a way to integrate gRPC into existing architectures with strict JSON/REST interface requirements.

There will then be a live demo showing the power of this workflow by iterating on a simple design. The audience will be able to follow along on their own by cloning the [boilerplate repository](https://github.com/johanbrandhorst/grpc-gateway-boilerplate).

Gradually more complicated topics like PATCH requests, middleware, authentication, working with browser clients, cookies, WebSockets and more will be introduced.