grpc-elixir - The Elixir implementation of gRPC

•    Elixir

---

The Elixir implementation of gRPC. You can start the gRPC server as a supervised process. First, add GRPC.Server.Supervisor to your supervision tree.

grpc elixir grpc-elixir rpc http2 protobuf google-protocol-buffers proto

grpcc - A gRPC cli interface for easy testing against gRPC servers

•    Javascript

---

grpcc is a flexible command-line client for any gRPC server for quick and easy testing of APIs. grpcc is written in nodejs but can talk to a gRPC service written in any language. By default, grpcc will attempt to make a secure connection to the service. If you need an insecure connection, you can pass in the -i flag.

grpc grpc-client devops devtools developer-tools http2 protobuf protobuf3 cli proto

polyglot - A universal grpc command line client

•    Java

---

In particular, it is not necessary to generate grpc classes for the service or to compile the protos into the Polyglot binary. All you need to run Polyglot is a Java runtime. Binaries for Mac, Linux, and Windows are available from the releases page.

grpc client command-line universal protobuf

go-grpc-prometheus - Prometheus monitoring for your gRPC Go servers.

•    Go

---

Prometheus monitoring for your gRPC Go servers and clients. A sister implementation for gRPC Java (same metrics, same semantics) is in grpc-ecosystem/java-grpc-prometheus.

prometheus grpc interceptor monitoring metrics

grpc-rust - Rust implementation of gRPC

•    Rust

---

Rust implementation of gRPC protocol, under development. Some development questions in FAQ.

grpc http2 protobuf tokio-rs

ts-protoc-gen - Protocol Buffers Compiler (protoc) plugin for TypeScript and gRPC-Web.

•    TypeScript

---

This repository contains a protoc plugin that generates TypeScript declarations (.d.ts files) that match the JavaScript output of protoc --js_out=import_style=commonjs,binary. This plugin can also output service definitions as both .js and .d.ts files in the structure required by grpc-web. This plugin is tested and written using TypeScript 2.7.

protocol-buffers protoc plugin typescript ts grpc-web grpc protobuf service proto3

nrpc - nRPC is like gRPC, but over NATS

•    Go

---

nRPC is an RPC framework like gRPC, but for NATS. It can generate a Go client and server from the same .proto file that you'd use to generate gRPC clients and servers. The server is generated as a NATS MsgHandler.

grpc protobuf rpc-framework

twirp - A simple RPC framework with protobuf service definitions

•    Go

---

Twirp is a framework for service-to-service communication emphasizing simplicity and minimalism. It generates routing and serialization from API definition files and lets you focus on your application's logic instead of thinking about folderol like HTTP methods and paths and JSON. For more on the motivation behind Twirp (and a comparison to REST APIs and gRPC), the announcement blog post is a good read.

twirp rpc protobuf

prototool - Your Swiss Army Knife for Protocol Buffers

•    Go

---

Protobuf is one of the best interface description languages out there - it's widely adopted, and after over 15 years of use, it's practically bulletproof. However, working with Protobuf and maintaining consistency across your Protobuf files can be a pain - protoc, while being a tool that has stood the test of time, is non-trivial to use, and the Protobuf community has not developed common standards with regards to stub generation. Prototool aims to solve this by making working with Protobuf much simpler. Prototool accomplishes this by downloading and calling protoc on the fly for you, handing error messages from protoc and your plugins, and using the generated FileDescriptorSets for internal functionality, as well as wrapping a few great external libraries already in the Protobuf ecosystem.

protobuf protocol-buffers protoc grpc grpc-go proto3

grpc-gateway - gRPC to JSON proxy generator following the gRPC HTTP spec

•    Go

---

grpc-gateway is a plugin of protoc. It reads gRPC service definition, and generates a reverse-proxy server which translates a RESTful JSON API into gRPC. This server is generated according to the google.api.http annotation in your gRPC service definition. It helps you to provide your APIs in both gRPC and RESTful style at the same time.

grpc grpc-gateway rest-api restful-api

go-micro-services - HTTP up front, Protobufs in the rear

•    Go

---

An demonstration of Golang micro-services that expose a HTTP/JSON frontend and then leverages gRPC for inter-service communication. The web page makes an HTTP request to the API Endpoint which in turn spawns a number of RPC requests to the backend services.

microservice grpc protobuf jaeger consul

grpc-web - gRPC Web implementation for Golang and TypeScript

•    TypeScript

---

gRPC-Web is a cutting-edge spec that enables invoking gRPC services from modern browsers. If you are looking for gRPC support for Node.js there is an official Node.js gRPC library. This package supports Node.js, but requires that the server has the gRPC-Web compatibility layer (read on to understand more).

grpc grpc-web browser typescript

rejoiner - Generates a unified GraphQL schema from gRPC microservices and other Protobuf sources

•    Java

---

These features are actively being developed.SchemaModule is a Guice module that is used to generate parts of a GraphQL schema. It finds methods and fields that have Rejoiner annotations when it's instantiated. It then looks at the parameters and return type of these methods in order to generate the appropriate GraphQL schema. Examples of queries, mutations, and schema modifications are presented below.

graphql-server protobuf grpc graphql

grpc-swift - The Swift language implementation of gRPC.

•    C

---

This repository contains an experimental Swift gRPC API and code generator.It is intended for use with Apple's swift-protobuf support for Protocol Buffers. Both projects contain code generation plugins for protoc, Google's Protocol Buffer compiler, and both contain libraries of supporting code that is needed to build and run the generated code.

console - tokio-console prototypes

•    Rust

---

a wire protocol for streaming diagnostic data from instrumented applications to diagnostic tools. the wire format is defined using gRPC and protocol buffers, for efficient transport on the wire and interoperability between different implementations of data producers and consumers. the console-api crate contains generated code for this wire format for projects using the tonic gRPC implementation. additionally, projects using other gRPC code generators (including those in other languages!) can depend on the protobuf definitions themselves.

Tonic - A native gRPC client & server implementation with async/await support.

•    Rust

---

A rust implementation of gRPC, a high performance, open source, general RPC framework that puts mobile and HTTP/2 first. Tonic is a gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility. This library was created to have first class support of async/await and to act as a core building block for production systems written in Rust.

async grpc rpc proto http2 rpc-framework networking network-library

go-microservice-helpers - A collection of handy snippets that simplify creation of GRPC servers and clients

•    Go

---

A collection of handy snippets that simplify creation of GRPC servers and clients. The provided helpers allow to create grpc endpoints with zipkin distributed tracing pre-configured; spawn http servers that serve both grpc and common http traffic; simplify golang crypto primitives to load EC keys.

grpc grpc-client grpc-server jwt tracing opentracing zipkin

grpc-proxy - gRPC proxy is a Go reverse proxy that allows for rich routing of gRPC calls with minimum overhead

•    Go

---

The project now exists as a proof of concept, with the key piece being the proxy package that is a generic gRPC reverse proxy handler. The package proxy contains a generic gRPC reverse proxy handler that allows a gRPC server to not know about registered handlers or their data types. Please consult the docs, here's an exaple usage.

grpc proxy

go-grpc-middleware - Golang gRPC Middlewares: interceptor chaining, auth, logging, retries and more.

•    Go

---

gRPC Go Middleware: interceptors, helpers, utilities. gRPC Go recently acquired support for Interceptors, i.e. middleware that is executed either on the gRPC Server before the request is passed onto the user's application logic, or on the gRPC client either around the user call. It is a perfect way to implement common patterns: auth, logging, message, validation, retries or monitoring.

grpc middleware generic-functions library logging authentication retries testing interceptor

Armeria - Build any type of microservice leveraging your favorite technologies, including gRPC, Thrift, Kotlin, Retrofit, Reactive Streams, Spring Boot and Dropwizard

•    Java

---

Armeria is your go-to microservice framework for any situation. You can build any type of microservice leveraging your favorite technologies, including gRPC, Thrift, Kotlin, Retrofit, Reactive Streams, Spring Boot and Dropwizard. Armeria is capable of running services using different protocols, all on a single port. No need for any proxies or sidecars.

http microservices netty micro-framework http2 gateway grpc http-client thrift rpc http-server rpc-server rpc-client rpc-framework thrift-server rpc-library hacktoberfest thrift-client grpc-server grpc-client rest-api