Best of gRPC — 2024
- 1
- 2
ITNEXT·2y
Performance Benchmarking: gRPC+Protobuf vs. HTTP+JSON
A performance benchmarking experiment compared gRPC with Protocol Buffers to HTTP with JSON for microservices communication in Go. The tests, run on a local machine, showed that HTTP/2 was slower than gRPC, which in turn was slower than HTTP/1. Despite these results, Protocol Buffers over gRPC remain an effective choice for inter-service communication due to its structured format.
- 3
Community Picks·2y
gRPC
gRPC is a high-performance, open-source RPC framework that connects services across data centers and to backend services from devices, mobile apps, and browsers. It uses Protocol Buffers for service definitions, supports quick scaling, works across various languages and platforms, and offers bi-directional streaming with integrated authentication.
- 4
Why is gRPC so much faster than a JSON-based REST API?
gRPC is faster than a JSON-based REST API primarily due to its use of HTTP/2 and Protobuf. HTTP/2 reduces request wait times through asynchronous requests and connection reuse. Protobuf, being binary-based, is more compact and faster during serialization/deserialization compared to JSON. While gRPC offers significant performance benefits, it also introduces complexities in load distribution, troubleshooting, and managing contracts. It's recommended for scenarios needing high performance and capable of handling its complexities, though REST + JSON remains a viable option.
- 5
- 6
Lobsters·2ygRPC: 5 Years Later, Is It Still Worth It?
The post reflects on the decision to use gRPC and Protobuf instead of OpenAPI/Swagger for Torq's technology stack, highlighting the enhanced backward compatibility, enforceable standards, and streamlined development process it provided. It covers advancements in code generation with tools like buf.build, improved module dependency management with Buf Schema Registry (BSR), and discusses the benefits and challenges of using gRPC-web for frontend development. The author affirms gRPC as their preferred protocol, bolstered by robust tool support and the use of service meshes like linkerd for better load balancing and security.
- 7
- 8
gRPC fundamentals with Go
gRPC is a powerful tool for establishing robust and scalable communication between server applications. This post explores using gRPC with Go through a practical example of a coffee shop, demonstrating how to define messages using Protocol Buffers, generate code, implement a server, and create a client. Key advantages of gRPC over REST APIs include type safety, performance optimization, and efficient handling of large data transfers through features like streaming RPCs.
- 9
- 10
codeHeim·2y
#55 Golang - Get Started with gRPC in Golang – Server & Client
Explore how gRPC, a high-performance RPC framework, allows seamless communication between services in Golang. Learn about its benefits over REST, how to set up gRPC and protocol buffers in a Go project, and see an example project structure implementing CRUD operations with gRPC.
- 11Lobsters·2y
Working with Protobuf in 2024
Protocol Buffers (protobuf), a data serialization tool from Google, has become integral in software development for its compact data structuring. Traditional workflows involving manual compilation and error-prone build steps have seen improvements with new tooling. Innovations like JSON to Proto, Protobuf Pal, and Buf CLI simplify protobuf development, offering features such as automated code generation, dependency management, and consistent code formatting. Tools like Buf Studio, Postman, Insomnia, and k6 further enhance testing capabilities. FauxRPC allows developers to create realistic mock gRPC services for faster prototyping. These advancements collectively streamline protobuf workflows and improve productivity.
- 12Lobsters·2y
gRPC Over HTTP/3
HTTP/3 offers a range of benefits for gRPC services, including faster connection establishment, eliminating head-of-line blocking, and mandatory encryption via TLS 1.3. The post explores the practical implementation of gRPC servers and clients over HTTP/3 using Go's ConnectRPC and quic-go libraries. HTTP/3 leverages QUIC, a protocol built on UDP, to reduce latency and improve performance. Despite the early adoption phase, the potential for enhanced performance and security in API development is evident. Practical examples and experimentation reveal current capabilities and limitations of gRPC over HTTP/3.
- 13
Hacker News·2y
gRPC: The Bad Parts
gRPC is a high-performance RPC framework with widespread language support, but it has its downsides. Key issues include a steep learning curve with complex terminology, reliance on HTTP/2 which isn't fully supported by browsers, lack of early standardized JSON mapping, and challenges with finite message sizes requiring complex implementation. Furthermore, gRPC's tooling and community engagement could be improved. Some of these problems are being addressed, such as better HTTP/3 support and advanced tools like the Buf CLI, but ongoing efforts are needed to unlock gRPC's full potential.
- 14
gRPC From Scratch: Part 1 - Client
An in-depth exploration of the gRPC protocol, explaining its structure and underlying mechanisms. The post covers the basics of creating a gRPC client in Go, detailing how requests and responses are encoded and decoded at a byte level. It also briefly touches on the topic of gRPC streaming and provides a simple example to get started.
- 15
How To Build A Containerized Microservice in Golang: A Step-by-step Guide with Example Use-Case
Learn how to build a cloud-native application using Golang and microservices architecture. The guide covers setting up microservices, leveraging the Go-Kit framework, developing APIs using REST and gRPC, and deploying on Azure. Follow along to create a document watermarking service with three microservices: Authentication, Database, and Watermark Service. Detailed steps include project structure, service implementation, and setting up HTTP and gRPC transports.
- 16
Baeldung·2y
Protobuf vs. gRPC
Microservices architecture relies on efficient communication methods. Protobuf, a language-neutral mechanism for serializing structured data, offers compact and efficient data transfer but lacks human readability. gRPC, an open-source RPC framework built on HTTP/2 and using Protobuf for defining services, enables high-performance communication with features like streaming and multiplexing. While Protobuf excels in data serialization, gRPC provides a robust RPC framework suitable for real-time data exchange. The choice between them depends on specific needs, balancing efficiency, readability, and ease of configuration.
