grpc-elixir - The Elixir implementation of gRPC

  •        54

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

https://github.com/tony612/grpc-elixir

Tags
Implementation
License
Platform

   




Related Projects

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.

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.

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.

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.

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.


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.

grpc-rust - Rust implementation of gRPC

  •    Rust

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

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.

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.

evans - Evans: more expressive universal gRPC client

  •    Go

above usecases is corresponding to Evans's two modes, REPL mode, and command-line mode. proto file which read in demonstration and its implementation are available at ktr0731/evans-demo.

proteus - Generate .proto files from Go source code.

  •    Go

Proteus /proʊtiəs/ is a tool to generate protocol buffers version 3 compatible .proto files from your Go structs, types and functions. The motivation behind this library is to use Go as a source of truth for your models instead of the other way around and then generating Go code from a .proto file, which does not generate idiomatic code.

protobuf-c - Protocol Buffers implementation in C

  •    C++

This is protobuf-c, a C implementation of the Google Protocol Buffers data serialization format. It includes libprotobuf-c, a pure C library that implements protobuf encoding and decoding, and protoc-c, a code generator that converts Protocol Buffer .proto files to C descriptor code, based on the original protoc. protobuf-c formerly included an RPC implementation; that code has been split out into the protobuf-c-rpc project. protobuf-c's mailing list is hosted on a Google Groups forum. Subscribe by sending an email to protobuf-c+subscribe@googlegroups.com.

exprotobuf - Protocol Buffers in Elixir made easy!

  •    Elixir

exprotobuf works by building module/struct definitions from a Google Protocol Buffer schema. This allows you to work with protocol buffers natively in Elixir, with easy decoding/encoding for transport across the wire. The 1.0 release removed the feature of handling import "..."; statements. Please see the imports upgrade guide for details if you were using this feature.

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.

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.

MagicOnion - gRPC based HTTP/2 RPC Streaming Framework for .NET, .NET Core and Unity.

  •    CSharp

gRPC based HTTP/2 RPC Streaming Framework for .NET, .NET Core and Unity.for .NET 4.6, 4.7 and .NET Standard 1.5(.NET Core) available in NuGet. Unity supports see Unity Supports section. HttpGateway + Swagger Intergarion supports see Swagger section.

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.

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.





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.