Cloud Native Computing Foundation / gRPC Conf 2020

Challenges and Learnings: Building gRPC Python AsyncIO Stack - Lidi Zheng, Google

One of Python 3’s most significant improvements is AsyncIO -- the official asynchronous library. The split Python asynchronous world now shares a common destination. Although this feature has been asked to integrate with gRPC back in 2015, it never really happened until now. In this session, we will discuss the challenges of integrating an asynchronous paradigm with gRPC Core, the designs that are tailored to the AsyncIO world, and, most importantly, the collaborations from the open-source community.

From WCF to gRPC - Mark Rendle, Gibraltar Software

In 2006, distributed systems meant Service Oriented Architecture, and SOA meant SOAP. Microsoft created the closed-source, platform-specific Windows Communication Foundation (WCF) to enable .NET developers to build SOAP-based applications, services and clients using C# or VB.NET. 15 years later, .NET Core is open source and cross-platform, WCF is being retired, and Microsoft are recommending gRPC as the preferred solution. But can gRPC do everything that WCF did? In this session, Mark Rendle will look at the different modes and bindings of WCF, like two-way "duplex" bindings and server-side sessions, and show how similar functionality can be achieved in gRPC with ASP.NET Core 3.1, with all the performance and interoperability benefits of the gRPC protocol.

Keynote: A Simplified Service Mesh With gRPC - Srini Polavarapu, Engineering Manager, Google

gRPC is a popular choice for building microservices based applications but it does not have any native service mesh features such as service discovery, load balancing, application security and observability. A service mesh typically provides such features via sidecar proxies deployed alongside the microservices. In this session, we will introduce the new exciting development of service mesh features in gRPC and show how to bring the benefits of a service mesh to your gRPC applications without the complexity of managing sidecar proxies. We will also talk about the architecture and show how you can go from a proxy based service mesh to a proxy-less service mesh with gRPC.

Keynote: Apache Beam Making Big Data Portable With gRPC - Ismaël Mejía, Software Engineer, Talend

Apache Beam is a unified programming model designed to create efficient and portable data processing pipelines. Portability in Apache Beam has two meanings: Users of Apache Beam can run their programs in different execution systems e.g. Apache Spark, Apache Flink, etc and they can choose their favorite (supported) language and be able to execute pipelines even if the targeted execution system does not support the language natively. In this talk we introduce Beam, its architecture based on translators (runners) and its portability framework: a set of gRPC services to coordinate the execution of functions isolated in language specific environments. The use of gRPC on Beam provides not only clear and easy to evolve contracts to coordinate the execution of functions but it offers nice isolation properties if combined with containers.

Keynote: Lessons Learned in Building a gRPC Implementation for .NET Core - Sourabh Shirhatti, Senior Program Manager & John Luo, Software Engineer, Microsoft

John Luo and Sourabh Shirhatti are part of the ASP.NET team at Microsoft working on the .NET Core implementation of gRPC. In this talk, they'll cover their experience in building a new gRPC implementation. They'll start by covering the design and limitations imposed by the existing .NET gRPC library and how the library attempts to address these concerns. As part of this deep dive, they'll also cover some of the design decisions that made in designing an opinionated framework and showcase the productivity and performance benefits introduced by the new library.

Keynote: Opening Remarks - April Nassi, Program Manager, Google

Keynote: Opening Remarks - James Ward, Developer Advocate, Google

Keynote: docs docs docs docs docs docs docs docs docs docs docs docs - Erin McKean, Docs Advocacy Program Manager, Google Open Source Programs Office

Next Level gRPC With Kotlin and Coroutines - Marco Ferrer, OfferUp

When it comes to async programming on the JVM, Kotlin Coroutines are leading the pack in both versatility and performance. This session will cover how the usage of Coroutines improves the ergonomics of APIs from both a client and server perspective. It will also cover the key benefits gained by adopting the practice of structured concurrency. Attendees will learn how Coroutines enable clients and services to participate in cooperative cancellation across network boundaries. Improving overall resource utilization. See how Coroutine suspension maps naturally to gRPC's backpressure mechanisms. After which we will dive into the state of the gRPC ecosystem for Kotlin. Analyzing what the available options are for current users and what the future has in store for the ecosystem.

Protop: A Package Manager for gRPC and Protocol Buffers - Jeffery Shivers, Toast, Inc

This presentation will cover a new open source tool called protop (pronounced “proto p”) which enables developers to easily publish and share protocol buffers across code bases. Protop was created as a lightweight solution for projects that need access to the same protobufs, such as common libraries that span multiple services, or even external gRPC APIs. The tool can be plugged into most pipelines or projects with a minimal footprint, and aims to encourage projects to keep protobuf schemas small, portable, and ultimately separate from their implementations. We’ll see how protop works through a few real examples and examine how it might help accomplish good development practices in the world of gRPC, especially in collaborative and open-source contexts.

Real World Migration from HTTP to gRPC in Ruby - Nao Minami, Wantedly, Inc.

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.

Service Interoperability With gRPC - Varun Gupta & Tuhin Kanti Sharma, Salesforce

This session will talk about the need for standardization for service to service communication at Salesforce and a solution that is implemented using gRPC across polyglot systems. We will share the implementation of our framework for Last Known Good [Artifact] service using gRPC. We will discuss how we used Java Spring Boot to implement a gRPC call framework and integrated it with a standard authentication protocol used at Salesforce. We will also share our future plans of moving to reactive streams for our gRPC service in Java.

Sponsored Keynote: Cheryl Hung, Director of Ecosystem, Cloud Native Computing Foundation & Leonardo Pistone, Senior Site Reliability Engineer, Spotify

Stop Breaking the Proto! Designing for Change in an Microservices World - Ryan Michela, Salesforce

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.

Talking to Go gRPC Services Via HTTP/1 - Malte Isberner, StackRox Inc. & StackRox GmbH

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.

Writing REST Services for the gRPC-curious - Johan Brandhorst, Buf

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.