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

  •        26

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.

https://github.com/grpc-ecosystem/grpc-gateway

Tags
Implementation
License
Platform

   




Related Projects

armeria - Asynchronous RPC/REST library built on top of Java 8, Netty, HTTP/2, Thrift and gRPC

  •    Java

Visit the official web site for more information.Armeria is an open-source asynchronous RPC/API client/server library built on top of Java 8, Netty 4.1, HTTP/2, Thrift and gRPC. Its primary goal is to help engineers build high-performance asynchronous microservices that use HTTP/2 as a session layer protocol.

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.

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).

ratelimit - Go/gRPC service designed to enable generic rate limit scenarios from different types of applications

  •    Go

The rate limit service is a Go/gRPC service designed to enable generic rate limit scenarios from different types of applications. Applications request a rate limit decision based on a domain and a set of descriptors. The service reads the configuration from disk via runtime, composes a cache key, and talks to the Redis cache. A decision is then returned to the caller. Envoy's data-plane-api defines a ratelimit service proto rls.proto. Logically the data-plane-api rls is equivalent to the ratelimit.proto defined in this repo. However, due to the namespace differences and how gRPC routing works it is not possible to transparently route the legacy ratelimit (ones based in the ratelimit.proto defined in this repo) requests to the data-plane-api definitions. Therefore, the ratelimit service will upgrade the requests, process them internally as it would process a data-plane-api ratelimit request, and then downgrade the response to send back to the client. This means that, for a slight performance hit for clients using the legacy proto, ratelimit is backwards compatible with the legacy proto.

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-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.

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-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.

grpcurl - Like cURL, but for gRPC: Command-line tool for interacting with gRPC servers

  •    Go

grpcurl is a command-line tool that lets you interact with gRPC servers. It's basically curl for gRPC servers. The main purpose for this tool is to invoke RPC methods on a gRPC server from the command-line. gRPC servers use a binary encoding on the wire (protocol buffers, or "protobufs" for short). So they are basically impossible to interact with using regular curl (and older versions of curl that do not support HTTP/2 are of course non-starters). This program accepts messages using JSON encoding, which is much more friendly for both humans and scripts.

bloomrpc - GUI Client for GRPC Services

  •    TypeScript

The missing GUI Client for GRPC services. Inspired by Postman and GraphQL Playground. BloomRPC aim to give the simplest and efficient developer experience for exploring and querying your GRPC services.

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-web - gRPC for Web Clients

  •    C++

gRPC-Web provides a Javascript library that lets browser clients access a gRPC service. You can find out much more about gRPC in its own website. The current release is a Beta release, and we expect to announce General-Availability by Oct. 2018.

gRPC-Java - The Java gRPC implementation. HTTP/2 based RPC

  •    Java

In gRPC a client application can directly call methods on a server application on a different machine as if it was a local object, making it easier for you to create distributed applications and services. As in many RPC systems, gRPC is based around the idea of defining a service, specifying the methods that can be called remotely with their parameters and return types.

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.

cilium - HTTP, gRPC, and Kafka Aware Security and Networking for Containers with BPF and XDP

  •    Go

Cilium is open source software for providing and transparently securing network connectivity and loadbalancing between application workloads such as application containers or processes. Cilium operates at Layer 3/4 to provide traditional networking and security services as well as Layer 7 to protect and secure use of modern application protocols such as HTTP, gRPC and Kafka. Cilium is integrated into common orchestration frameworks such as Kubernetes and Mesos. A new Linux kernel technology called BPF is at the foundation of Cilium. It supports dynamic insertion of BPF bytecode into the Linux kernel at various integration points such as: network IO, application sockets, and tracepoints to implement security, networking and visibility logic. BPF is highly efficient and flexible. To learn more about BPF, read more in our extensive BPF and XDP Reference Guide.

doorman - Doorman: Global Distributed Client Side Rate Limiting.

  •    Go

Doorman is a solution for Global Distributed Client Side Rate Limiting. Clients that talk to a shared resource (such as a database, a gRPC service, a RESTful API, or whatever) can use Doorman to voluntarily limit their use (usually in requests per second) of the resource. Doorman is written in Go and uses gRPC as its communication protocol. For some high-availability features it needs a distributed lock manager. We currently support etcd, but it should be relatively simple to make it use Zookeeper instead.The Doorman master server remembers all clients that currently have capacity and whenever a client asks for capacity it inserts the clients request into its memory and runs the algorithm to figure out what this client should get.

grpc-go - The Go language implementation of gRPC. HTTP/2 based RPC

  •    Go

The Go implementation of gRPC: A high performance, open source, general RPC framework that puts mobile and HTTP/2 first. For more information see the gRPC Quick Start: Go guide.This requires Go 1.7 or later.

colossus - Colossus — An example microservice architecture for Kubernetes using Bazel, Go, Java, Docker, Kubernetes, Minikube, Gazelle, gRPC, Prometheus, Grafana, and more

  •    Python

Wait a second, these services don't do anything meaningful! Nope, they sure don't. But that's okay because the point of this project is to show you how to get the basic (yet not-at-all-trivial) plumbing to work. Colossus is a boilerplate project that's meant as a springboard to more complex and meaningful projects. Getting all of these technologies to work together was a real challenge. I had to dig through countless GitHub issues and dozens of example projects to make all these things work together. I'm offering this repo as a starter pack for other people with a Bazel monorepo targeting Kubernetes.

grpc-rust - Rust implementation of gRPC

  •    Rust

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

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.





We have large collection of open source products. Follow the tags from Tag Cloud >>


Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.