apache/dubbo-go

Features

• Cross-Language RPC Frameworks - Facilitates high-performance remote procedure calls between Go and Java services using standardized data encoding.
• Remote Procedure Call Frameworks - Implements a high-performance RPC framework for efficient data exchange between distributed microservices.
• Load Balancing - Distributes outgoing requests across multiple service providers using algorithms like round-robin and consistent hashing.
• Load Balancing Strategies - Distributes outgoing requests across multiple service instances using interchangeable algorithms like round-robin or consistent hashing.
• Microservice Traffic Management - Controls request flow through load balancing, circuit breakers, and dynamic routing to ensure system resilience.
• Service Governance Control Planes - Coordinates service registration, health checks, and metadata management across a cluster of distributed application instances.
• Microservices Communications - Handles service registration, health checking, and request tracing across distributed microservice clusters.
• Registry-Based Service Discovery - Locates available service providers by querying a centralized registry instead of using hardcoded network addresses.
• RPC Frameworks - Provides a high-performance framework for executing remote procedures across network nodes.
• Dubbo Integration - Implements the Apache Dubbo framework in Go for building high-performance microservices.
• Service Governance - Provides a toolset for managing service discovery, load balancing, and traffic routing in distributed architectures.
• Proxyless Integrations - Enables data planes to connect with external control planes in both proxy and proxyless modes.
• Compatibility Layers - Handles Java-specific data types and exceptions to enable seamless communication between Go and Java-based services.
• Language Bridges - Maps language-specific data types and exceptions to enable seamless communication between services written in different languages.
• Language Interoperability - Enables interaction between services written in different programming languages using language-agnostic definitions and standardized encoding.
• Dynamic Service Discovery - Locates available service providers in real-time using registry adapters, local file systems, or custom extensions.
• Polyglot Microservices - Enables communication between services written in different languages through standardized data exchange and shared interfaces.
• Distributed Observability Systems - Provides unified observability for distributed systems through integrated metrics, tracing, and performance monitoring.
• Invocation & Routing Extensions - Provides a plugin system to customize how remote procedure calls are invoked and routed.
• RPC Stub Generation - Produces client and server code from interface definitions to automate service contract implementation.
• Interface Definition Code Generation - Produces client and server stubs from shared interface definitions to automate the implementation of service contracts.
• Dynamic Configuration Updates - Updates system settings at runtime using external configuration centers without requiring an application restart.
• High Availability Services - Ensures service availability by implementing failover, failfast, and broadcast routing strategies during interruptions.
• Data Plane Implementations - Acts as a data plane implementation connecting services to an external control plane for centralized governance.
• Service Lifecycle Management - Coordinates graceful shutdowns and offline transitions to ensure requests finish processing before service exit.
• Correlation Tracing - Injects correlation identifiers into service calls to track the flow of a single request across multiple microservices.
• Multi-Protocol Transport Layers - Routes communication over a single port and switches between different wire formats based on configuration.
• Service Mesh Networking - Protects inter-service communication using transport layer encryption and identity-based access control.
• Service Metadata Management - Manages service definitions and metadata to support advanced governance and precise request routing.
• Single-Port Multi-Protocol Support - Publishes multiple communication standards on a single port to support various network protocols for service interaction.
• Circuit Breakers - Prevents cascading failures by monitoring error rates and temporarily blocking requests to unhealthy service providers.
• Dynamic Routing - Steers traffic based on rules, scripts, or tags to enable canary releases and grayscale deployments.
• Transport Protocol Switching - Allows toggling between different communication protocols on a single port using simple configuration settings.
• Service Communication Security - Establishes a zero-trust network using transport encryption and identity-based permission verification.
• Environment Abstraction Layers - Decouples application logic from the underlying execution environment, supporting VMs, containers, and service meshes.
• Pluggable Interceptor Chains - Executes a sequence of customizable interceptors for request and response processing to extend framework behavior.
• Generic Invocations - Allows calling remote methods without requiring the specific interface definition to be present on the client side.
• Traffic Flow Control - Protects services from overload through TPS capping, execution limits, and rate limiting mechanisms.
• Configuration Hot-Reloading - Updates application settings at runtime using external configuration centers without requiring a process restart.
• Metric Collection - Collects request totals, success rates, and response time quantiles via sliding windows to track efficiency.
• Distributed Tracing - Tracks single requests across multiple services to identify performance bottlenecks and failures.
• Service Health Monitoring - Visualizes service running status and performance using metrics, distributed tracing, and access logs.
• Messaging and RPC - A Go implementation of the Dubbo framework for service interoperability.
• RPC Frameworks - Go implementation of the Dubbo RPC framework.

Historial de estrellas