RocketMQ 5.0 introduces a brand‑new unified API built on gRPC, refines client types, adds four message categories, pre‑fetches topic routes, embeds a telemetry channel, and provides OpenTelemetry‑based tracing and metrics, all while offering a cloud‑native SDK repository for developers.
This article introduces gRPC, explains its HTTP/2 and Protocol Buffers foundations, walks through writing and compiling .proto files, provides complete Python server and client examples, and shows how to quickly set up the environment and integrate gRPC into microservice and Kubernetes deployments.
Airbnb’s engineering team describes how they migrated to Kubernetes, evolved their clusters through three stages, and built a custom gRPC‑based expander for the Cluster Autoscaler to achieve flexible, cost‑effective, and automated scaling across hundreds of heterogeneous clusters.
This article explains the fundamentals of Remote Procedure Call (RPC), compares popular RPC frameworks such as gRPC, Thrift, Dubbo and Spring Cloud, details gRPC’s architecture, Protocol Buffers serialization, HTTP/2 advantages, and provides a step‑by‑step Java demo with full source code and performance benchmarks.
This article walks through the complete design of a service registry—from requirement analysis and interface definition to push mechanisms, health‑check strategies, long‑connection technology choices, data storage options, and high‑availability considerations—providing a practical blueprint for building a production‑grade registry.
Airbnb migrated its services to Kubernetes and, over four years, evolved from manual scaling of homogeneous clusters to heterogeneous clusters with automated scaling, introducing a custom gRPC expander for the Cluster Autoscaler that enables weighted priority and plug‑in extensibility, reducing costs and operational overhead.
The Shopee Games team created a custom Protobuf‑driven API gateway that unifies external HTTP and internal RPC traffic, automatically generates routing, authentication, logging and Swagger from proto annotations, shares capacity across services, and boosts performance and resource utilization for their micro‑service‑based casual gaming platform.
This article walks through building a gRPC server and client in Java, then demonstrates four performance‑testing models—static thread, static QPS, dynamic thread, and dynamic QPS—detailing the code, configuration, and execution steps for each, while explaining why the blocking stub is preferred for metric collection.
This article explains the OSI seven‑layer model, then compares RPC and HTTP services by detailing RPC’s architecture, synchronous versus asynchronous invocation, and the most popular open‑source RPC frameworks—gRPC, Thrift, and Dubbo—highlighting why RPC often offers higher efficiency for large‑scale enterprise applications.
This article explains how to replace Spring Cloud with Istio by creating a simple Spring Boot microservice that uses gRPC for communication, packaging it with Docker, deploying it on Kubernetes, and exposing it through an Istio gateway, complete with code examples and deployment instructions.
This article provides a step‑by‑step guide to creating a simple Spring Boot microservice that uses gRPC for communication, integrates with Istio as a service mesh, containerizes the applications with Docker, and deploys both server and client to a Kubernetes cluster with full configuration files and code examples.
This article walks through creating a simple Spring Boot microservice using gRPC, packaging it with Maven, containerizing it with Docker, and deploying both the server and client to a Kubernetes cluster with Istio sidecar injection, demonstrating how Istio removes service‑mesh logic from business code and enables seamless multi‑language microservice communication.
This article explains the fundamental distinctions between RPC and HTTP services, covering OSI network layers, the core components of RPC architecture, synchronous versus asynchronous calls, popular RPC frameworks such as gRPC, Thrift, and Dubbo, and a comparison with RESTful HTTP services.
This article explains the fundamental differences between RPC and HTTP services, covering OSI layers, RPC architecture, synchronous and asynchronous calls, and introduces popular RPC frameworks such as gRPC, Thrift, and Dubbo, while also showing a simple HTTP request example.
This article explains the fundamental differences between RPC (Remote Procedure Call) and HTTP services, covering OSI layers, RPC architecture components, synchronous vs asynchronous calls, and popular frameworks such as gRPC, Thrift, and Dubbo, to help developers choose the right approach.
This article explains how to unify error handling between gRPC and traditional HTTP services by defining shared protobuf messages, mapping gRPC status codes to HTTP responses, and customizing response structures with additional fields like stat and msg for consistent business‑level error reporting.
This article explains how to apply Apache Commons Pool2's GenericKeyedObjectPool to pool gRPC ManagedChannel objects, discusses thread‑safety and performance considerations, and provides concrete Java code for a keyed object pool factory, pool configuration, and typical acquire/return usage patterns.
This guide walks through three ways to create gRPC Java clients—newBlockingStub, newStub, and newFutureStub—showing their code, usage patterns, and performance characteristics, while also providing a simple server implementation for testing.
This article walks through setting up the Go environment, defining protobuf files, generating code, and implementing both server and client sides of a gRPC service, complete with runnable examples, common pitfalls, and output verification to help developers quickly adopt Go‑based gRPC testing.
This guide walks you through setting up a basic Java gRPC project by outlining required Maven dependencies, creating the .proto SDK, implementing a server with a custom service, building a client stub, and running a test to verify the end‑to‑end RPC call.
This article explains how Huawei Cloud EventGrid, powered by Apache EventMesh and gRPC, provides a serverless, high‑availability event bus that unifies HTTP, TCP, and message‑queue protocols, enabling composable applications to integrate seamlessly across cloud services and SaaS partners.
This article explains how to design a gRPC connection pool, covering scaling rules, idle‑connection timeout and keep‑alive, pool‑full handling, core gRPC features, and practical tuning parameters to achieve high performance in high‑concurrency backend services.
gRPC Core version 1.45.0 introduces numerous updates including XDS error handling, core version upgrade, memory leak fixes, transparent retries, channel credential improvements, Windows memory leak resolution, xDS RBAC filter updates, as well as language‑specific enhancements for C++, C#, Objective‑C, and Python.
The article details the architecture, key components, testing types, and operational results of Autohome's PTS platform, which uses Docker Swarm, gRPC, JMeter, Flume‑Kafka, and Flink to conduct large‑scale distributed load testing for the 818 event and outlines future improvements toward Kubernetes and direct Kafka logging.
This article explains what APIs are, introduces RPC and gRPC, compares them with REST across protocols, data formats, performance, code generation, and browser support, and offers guidance on when to choose gRPC or REST for microservice and mobile applications.
This article explains how Dubbo3’s Triple protocol, built on HTTP/2 and compatible with gRPC, improves performance, routing, security, and usability over classic RPC protocols like Dubbo2 and HTTP/1.1, while offering cross‑language support, streaming, and seamless integration with cloud‑native service governance.
This article introduces the high‑performance gRPC framework, explains why it uses HTTP/2 and Protocol Buffers, outlines its core components, and provides a step‑by‑step Python tutorial with environment setup, code generation, server and client implementations, and common application scenarios.
The investigation of QLB‑4‑based TFServing calls revealed uneven traffic, stale routing after scaling, and idle servers due to layer‑4 hash routing, leading the team to replace QLB‑4 with a Consul‑driven client‑side load‑balancer that dynamically pools servers, eliminates restarts, and cuts GPU waste.
This article explains the internal components of the kubelet, details the CRI architecture, outlines the roles of the Runtime and Image services, and provides code examples of the gRPC API definitions, helping readers grasp how Kubernetes manages containers and images.
This comprehensive guide walks you through creating a gRPC user service in Go and PHP, from defining protobuf messages and generating code, implementing server and client stubs, adding client, server, and bidirectional streaming, securing communication with TLS certificates, and managing request deadlines with timeout controls.
The iQIYI deep‑learning platform identified two TensorFlow Serving memory‑leak problems—a string‑accumulating executor map caused by unordered input maps and an uncontrolled gRPC thread surge under heavy load—submitted upstream patches that sort inputs and cap thread counts, eliminating OOM crashes and stabilizing production.
The article explains gRPC fundamentals, illustrating service definition in .proto files, synchronous and asynchronous client and server implementations with CompletionQueue and CallData state machines, streaming RPC patterns, HTTP/2 protocol details, metadata handling, and the structure of generated stub and service code.
This article explains the core concepts and detailed design of a custom message queue built on a distributed key‑value store, covering terminology, architecture, broker metadata, topic metadata, message format, sending, storage, retrieval, delay handling, retry mechanisms, dead‑letter queues, and TTL policies.
This article compares RPC and HTTP services by explaining their protocol foundations, the OSI network layers, RPC architecture components, synchronous versus asynchronous calls, and popular frameworks such as gRPC, Thrift, and Dubbo, while also outlining when each approach is appropriate for enterprise development.
Long Young GC pauses in gRPC/Netty services were traced to Netty’s default thread‑local cache creating many MpscArrayQueue objects, and disabling the cache with the JVM options ‑Dio.netty.allocator.useCacheForAllThreads=false and ‑Dio.grpc.netty.shaded.io.netty.allocator.useCacheForAllThreads=false reduced GC time from up to 900 ms to about 100 ms, stabilizing the service.
This guide explains how to upgrade Spring Boot projects to Nacos‑Spring‑Boot 0.2.10, covering new features such as full Nacos 2.0 compatibility, automatic config‑type detection, SpEL support, and high‑concurrency fixes, and provides step‑by‑step client and server deployment instructions with verification.
Pixiu is a Golang‑based, cloud‑native API gateway built on dubbo‑go that bridges RESTful and Dubbo services, offering high performance, extensibility, and easy configuration through Listener, Router, Filters, and Client modules, with roadmap plans for gRPC, mesh integration, and more.
This article explains how etcd 3.x switched its external API to gRPC, the challenges of using its gRPC‑gateway for HTTP requests in Apache APISIX, the default message size limit causing sync failures, and the certificate configuration pitfalls that were fixed through a PR merged in v3.5.0.
This article explains how to design and implement a secure gRPC gateway using OpenResty, analyzes performance bottlenecks such as excessive TIME_WAIT connections, and provides practical kernel and Nginx/OpenResty tuning steps to achieve long‑lived connections and lower latency.
This article introduces Alibaba's open‑source Nacos service for dynamic configuration and service discovery, explains its core features and the performance benefits of Nacos 2.x with gRPC, and provides step‑by‑step Spring Boot integration code, configuration examples, and a live demonstration using the Nacos web console.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI model, RPC architecture, synchronous vs asynchronous calls, and popular open‑source RPC frameworks such as gRPC, Thrift, and Dubbo, to help developers choose the right approach for large‑scale systems.
This article introduces Kaiyan Kuaichuang's Flutter‑based cross‑platform architecture, covering component layering, state‑management strategies (BLoC, Provider, Redux, Built_redux), data communication via gRPC/ProtoBuf, and a custom URL‑based routing solution, while sharing practical code snippets and lessons learned.
This article explores how Kuaishou Creative leverages Flutter for cross‑platform development, detailing its componentized architecture, page‑level and inter‑page state management approaches, data and page communication mechanisms, and the custom routing solution that unifies navigation across the app.
This article explains the fundamental differences between RPC and HTTP services, reviews the OSI network model, describes RPC architecture and sync/async calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo with traditional RESTful HTTP, and offers guidance on choosing the right approach for a project.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI network model, RPC architecture components, synchronous and asynchronous calls, and introduces popular open‑source RPC frameworks such as gRPC, Thrift, and Dubbo, before comparing their suitability for various enterprise scenarios.
The dubbo-go v1.5.6 release aligns with Dubbo 2.7.8 and introduces a CLI tool, proxy extensions, configurable file paths, custom ConfigPostProcessor, URL comparison enhancements, registration center optimizations, API‑based config, gRPC tweaks, and updates to dubbo-go‑hessian2, with a roadmap toward cloud‑native 3.x.
This article provides a comprehensive overview of microservice concepts, their differences from traditional SOA, the benefits of agility, scalability and independent deployment, and details RongShu Data's architectural choices, technology stack, design principles, DevOps platform, team organization, and practical implementation guidelines.
This article explains the fundamental differences between RPC and HTTP services, outlines the OSI model, describes RPC architecture, synchronous and asynchronous calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose each approach for backend development.
This article explains the fundamental differences between RPC and HTTP services, reviews the OSI network model, describes RPC architecture, synchronous and asynchronous calls, compares popular RPC frameworks such as gRPC, Thrift, and Dubbo, and discusses when to choose each approach for enterprise applications.
The article examines Nacos' evolution from its Alibaba origins, outlines the performance and resource problems of the 1.x architecture, and details how the 2.x version’s long‑connection gRPC model, improved reliability, and compatibility enhancements address those issues while introducing new complexities.
Protocol Buffers (ProtoBuf) is a language‑neutral, binary serialization format that enables compact, fast data exchange and easy backward‑compatible schema evolution across many languages, with automatic code generation, making it ideal for gRPC and storage despite being non‑human‑readable.
This article surveys major RPC frameworks—including Dubbo, Motan, Spring Cloud, gRPC, and Thrift—detailing their architectures, communication protocols, serialization formats, cross‑language support, and ecosystem components, and offers guidance on selecting the most suitable framework based on language requirements, performance, and feature completeness.
A mobile app gateway for e‑commerce platforms consolidates API exposure, connection pooling, HTTP/2 and QUIC multiplexing, unified encryption, custom DNS, caching and degradation strategies, while supporting heterogeneous back‑ends via gRPC and proxy services, thereby improving stability, speed, capacity planning and revenue.
This article provides a detailed overview of Nacos' evolution from its 1.x architecture to the 2.x version, explaining the layered design, service discovery model, identified shortcomings of the older version, and the enhancements introduced with long‑connection support, new data models, and performance optimizations.
The gRPC Core 1.34.0 release introduces numerous improvements and bug fixes across multiple language implementations, including new environment variable security support, Unix abstract socket URIs, enhanced xDS handling, updated platform compatibility, and added support for recent PHP, Python, and Ruby versions.
This article explains the fundamental differences between RPC and HTTP services, covering OSI layers, RPC architecture, synchronous and asynchronous calls, and popular RPC frameworks such as gRPC, Thrift, and Dubbo, while also comparing their suitability for large‑scale versus small‑scale applications.
This article explains the OSI model basics, compares RPC and HTTP service architectures, details synchronous and asynchronous calls, introduces major RPC frameworks like gRPC, Thrift, and Dubbo, and offers guidance on choosing between RPC and HTTP based on project needs.
This article shares Laiye Technology's practical experience with Protobuf and gRPC, covering performance benefits, common pitfalls such as naming and compatibility issues, and the engineering solutions they implemented—including naming conventions, review processes, unified CI compilation, automatic client generation, version tagging, and Swagger documentation—to streamline large‑scale microservice development.
This article explains the fundamentals of RPC protocols, compares common designs such as HTTP/1.1, RESP, HTTP/2, and gRPC, and outlines the motivations and key features of Dubbo 3.0’s next‑generation protocol for better performance, extensibility, and cross‑language support.
This article examines Eastern Securities' transition to a microservice architecture by detailing the design, implementation, and performance of its gRPC‑Nebula service‑governance framework and the Star‑Chen platform, covering challenges such as heterogeneous interfaces, service registration, load balancing, fault tolerance, traffic control, multi‑registry support, and real‑world deployment results.
This article details Eastern Securities' journey from monolithic systems to a microservice architecture, describing the design and implementation of the gRPC-Nebula service governance framework and the Starry Service Governance Platform, their technical features, performance tests, multi‑language support, and the practical outcomes of the digital transformation.
This guide explains the core concepts of TensorFlow Serving, shows how to prepare Docker images, save TensorFlow 2.x models in various formats, configure version policies, warm‑up models, start the service, and invoke it via gRPC or HTTP with complete code examples.
This article explains the core concepts of TensorFlow Serving, shows how to prepare the environment with Docker, convert TensorFlow 2.x models to the SavedModel format, configure version policies, warm‑up the service, and invoke predictions via gRPC or HTTP interfaces.
Microsoft has officially released gRPC‑Web for .NET, a JavaScript library that enables browsers to directly call backend gRPC services, offering significant performance gains over JSON and expanding gRPC usage to web, Blazor, IIS, Azure, and mobile platforms.
This article provides a step‑by‑step guide to using Google's open‑source gRPC framework in Java, covering Protocol Buffers service definitions, Maven configuration, Spring Boot server implementation, client creation, and unit testing to demonstrate cross‑language RPC communication.
The article surveys the open‑source microservice ecosystem, comparing RPC‑only frameworks like gRPC, language‑specific solutions such as Spring Cloud, emerging service‑mesh platforms, and Tencent’s multi‑language TARS which integrates full governance features, and explains their architectures, capabilities, and future direction.
This article provides a comprehensive beginner-friendly guide to gRPC, covering its definition, the protobuf syntax for defining messages and services, field constraints, supported data types, usage of the protoc tool, and complete Go examples for both server and client implementations.
This article explains the technical differences between RPC and HTTP services, covering the OSI model, RPC architecture, synchronous versus asynchronous calls, and compares popular frameworks like gRPC, Thrift, and Dubbo to help developers choose the right approach for large‑scale systems.
The Apache Dubbo 2.7.5 release introduces application‑level service registration, native HTTP/2 (gRPC) and Protobuf support, a 30% performance uplift, TLS security, an optimized consumer thread‑pool, a new Bootstrap API, multi‑registry load balancing, and numerous other enhancements aimed at cloud‑native microservice development.
This article outlines essential API design principles and best practices, covering simple, understandable, consistent, stable, and secure APIs, then delves into RPC mechanisms, Protobuf serialization, RESTful conventions, Swagger documentation, Spring Boot integration, HTTP/2 performance improvements, and the powerful combination of HTTP/2 with Protobuf in gRPC.
This article guides readers through preparing gRPC RPC scripts, creating Java sampler code for JMeter, packaging the scripts, and executing load tests to evaluate RPC performance, providing step‑by‑step instructions and code examples for Java‑based testing.
This article walks you through deploying a WebSocket chat service and a gRPC ping service on Knative, covering repository cloning, Docker image preparation, Knative Service YAML configuration, kubectl deployment commands, and browser‑based verification to ensure the services run correctly in a serverless environment.
This article benchmarks the throughput, average latency, median latency, and maximum latency of five RPC frameworks—Dubbo, Motan, rpcx, gRPC, and Thrift—using a unified protobuf‑based service across varying client concurrency levels, and discusses the resulting performance trends and conclusions.
This article details how the MX recommendation team rebuilt their Faiss‑based similarity search service using gRPC, covering service selection, multi‑type vector handling, dynamic index updates, deployment strategies, and performance gains that doubled QPS and cut latency by two‑thirds.
This article introduces RPC and gRPC concepts, explains how to define services with Protocol Buffers, and provides step‑by‑step Node.js and Go examples for building gRPC servers and clients, while covering language support, limitations, and reference resources.
Tencent’s Penguin Smart Pen Classroom uses a camera‑equipped dot‑matrix pen and a gRPC‑based micro‑service architecture on Tencent Cloud to capture handwriting, perform AI‑driven grading, share boards in real time, and generate personalized reports across three linked subsystems, scaling to thousands of schools.
This article presents a comprehensive overview of Huajiao's gRPC development practice, covering background decisions, gRPC features, gateway integration, Dart and Go client libraries, component architecture, protobuf conventions, code generation, SDK integration, documentation tooling, debugging strategies, and future roadmap.
This article details the technical decisions and implementation steps for a Flutter‑based mobile product that uses gRPC for high‑performance RPC, gRPC‑Web for browser compatibility, and gRPC‑Gateway to expose RESTful APIs, covering code generation, library design, debugging tricks, and future roadmap.
Learn how to efficiently debug grpc C++ addons on a server using gdb, covering preparation, launching Node.js under gdb, running tests, inspecting segmentation faults, setting breakpoints, and useful gdb commands to examine variables and call stacks.
This article recounts the migration of the Core Course (CC) service from a custom Ruby RPC framework to a Go‑based gRPC solution, detailing technical choices, performance bottlenecks, testing strategies, monitoring setup, and the substantial improvements achieved after launch.
This article provides a step‑by‑step guide on installing the Protobuf compiler, setting up the Go plugin, writing .proto definitions, generating Go code, and demonstrating serialization and deserialization of Protobuf messages in a Go application, complete with troubleshooting tips and reference links.
The 2018 developer‑tool roundup highlights Elasticsearch for log processing, gRPC for high‑performance RPC, the CNCF ecosystem (Kubernetes, Prometheus, etc.), Python’s AI dominance, cross‑platform Mini‑Programs, VSCode’s plugin‑rich IDE, Vue.js front‑end simplicity, GraphQL’s flexible APIs, and notes a shift toward mobile, cloud‑native infrastructure and commercial open‑source licensing.
This article compares REST, gRPC, GraphQL, and Webhooks, explaining the scenarios each is best suited for and helping developers decide which API design approach matches their project's performance, flexibility, and integration requirements.
This article explains Envoy's HTTP filter architecture, routing capabilities, gRPC integration, WebSocket handling, and cluster manager functions, detailing how each component operates without needing knowledge of underlying protocols and how they enable advanced traffic management, observability, and service mesh features.
This article shares practical Go microservice building experiences, covering gRPC-based communication, TLS security, request tracing, and comprehensive monitoring with Prometheus, including metric selection, alerting, and log management using Logrus and Graylog, to help reduce coupling and improve system observability.
This article traces the evolution of Remote Procedure Call (RPC) from its early definitions in the 1970s through various middleware implementations like CORBA, Java RMI, Thrift, and gRPC, highlighting key concepts, criticisms, and modern developments in distributed systems.
This tutorial explains how to set up protobuf and gRPC, generate code from .proto files, and create a simple Python client (wrapped with Flask) to query relay information for live cloud streaming services, providing a lightweight alternative to manual log inspection.
The article shares Google SRE veteran Minghua Ye’s insights on App Engine’s evolution, emphasizing the critical role of automatic scalability, distributed locks, service discovery, load balancing, and open‑source tools like gRPC, Protobuf, gflags, glog, and Googletest in building reliable, high‑traffic cloud services.
This article shares the engineering team’s experience of building a high‑growth, reliable backend for English Fluently, covering inter‑service communication with gRPC, service discovery, Docker‑based deployment, health‑checking, monitoring, autoscaling, Kubernetes orchestration, and multi‑cell availability strategies.
This article benchmarks four widely used RPC frameworks—Dubbo, Motan, rpcx, gRPC, and Thrift—by measuring throughput, average latency, median latency, and maximum latency under varying client concurrency levels, revealing rpcx’s superior performance and the impact of serialization choices.
Google's gRPC 1.0 release brings high‑performance, multi‑language RPC support built on Protocol Buffers and HTTP/2, enabling loosely coupled, scalable backend systems for data centers, mobile apps, IoT, and microservices with improved efficiency, security, and ecosystem adoption.
gRPC, an open‑source RPC framework built by Google on HTTP/2 and Protocol Buffers, offers strong IDL capabilities, multi‑language support, and efficient streaming that reduce bandwidth, CPU usage, and battery drain, making it ideal for low‑latency, scalable backend and mobile client architectures.
