Ecosystem Integration on Apache Dubbo

Use Apache APISIX to Proxy Dubbo Services (Triple Protocol)

Mon, 22 Apr 2024 00:00:00 +0000

For a description of how to proxy triple protocol services with a gateway, please refer to the section on HTTP Gateway Access.

This article demonstrates how to use the combination of Apache APISIX + triple protocol + Nacos registry to proxy Dubbo services.

Sample Application Description

The complete source code and deployment resource files for this example can be found at dubbo-samples-gateway-triple-apisix, with the architecture diagram as follows:

In this example, a triple service org.apache.dubbo.samples.gateway.apisix.DemoService has been defined and published, with the interface defined as:

Using Apache APISIX to Proxy Dubbo Services (Dubbo Protocol)

Thu, 25 Apr 2024 00:00:00 +0000

Note

This article is only applicable to the Dubbo protocol communication scenario. If you are a Dubbo3 user, it is recommended to use the triple protocol. Please refer to Using Apache APISIX to Proxy Dubbo Services (Triple Protocol) for specific examples.

Apache APISIX is a top-level open-source project of the Apache Software Foundation and the most active open-source gateway project currently. As a dynamic, real-time, high-performance open-source API gateway, Apache APISIX provides rich traffic management features such as load balancing, dynamic upstream, gray release, service circuit breaking, authentication, and observability.

How to Proxy Dubbo Services via Higress Gateway

Mon, 01 Apr 2024 00:00:00 +0000

Note

This article is only applicable to Dubbo protocol communication scenarios. If you are a Dubbo3 user, it is recommended to use the triple protocol. Please refer to Use Apache APISIX to Proxy Dubbo Services (triple protocol) for specific examples.

Higress provides the capability to convert from HTTP protocol to Dubbo protocol. Users can expose a Dubbo service as an HTTP interface by configuring protocol conversion, thus allowing HTTP requests to invoke Dubbo interfaces. This article introduces how to configure HTTP to Dubbo protocol conversion using Higress through an example. The example guides you to easily deploy a Nacos server and a Dubbo service, then forwards HTTP requests to the Dubbo service registered in Nacos through Ingress, and accomplishes HTTP calls to the Dubbo service through Higress’s protocol conversion capability.

Best Practices for Microservices: Zero Refactoring to Achieve Interoperability Between Spring Cloud and Apache Dubbo

Sat, 07 Oct 2023 00:00:00 +0000

This article uses real projects and code as examples, demonstrating step by step how to achieve interoperability between the Apache Dubbo system and the Spring Cloud system with minimal cost, enabling hybrid deployment and migration of different microservice systems, helping you solve practical architectural and business issues.

Background and Goals

If you are facing the following business scenarios during microservice development, this article can help you:

You already have a microservice application built on Dubbo, and now you need to publish some services through REST HTTP without changing the code, just adding some configurations and annotations for the pre-written Dubbo services.
You have a microservice system based on Spring Cloud and later built a set of microservices on Dubbo. You want both systems to coexist, requiring mutual access to services published by each other.
Due to historical reasons, you are planning to migrate from one microservice system to another, ensuring a smooth transition in the process.

Towards Native: Spring & Dubbo AOT Technical Examples and Principles Explanation

Wed, 28 Jun 2023 00:00:00 +0000

Java applications face issues such as slow “cold start”, high memory usage, and long warm-up times in the cloud computing era, making it difficult to adapt to cloud deployment models like Serverless. GraalVM addresses these issues significantly through static compilation and packaging techniques, and mainstream frameworks such as Spring and Dubbo provide corresponding AOT solutions to some of the limitations of GraalVM.

In this article, we will analyze the challenges faced by Java applications in the cloud era, how GraalVM Native Image addresses these issues, the basic concepts and working principles of GraalVM, and finally demonstrate how to statically package a typical microservice application with an example using Spring6 and Dubbo3.

How to Proxy Dubbo Services through Apache ShenYu Gateway

Wed, 04 May 2022 00:00:00 +0000

1. Introduction

Apache ShenYu

Apache ShenYu(Incubating) is an asynchronous, high-performance, cross-language, and responsive API gateway. Compatible with various mainstream framework systems, it supports hot swapping, and users can customize development to meet various current and future needs through large-scale scenario testing.

In May 2021, ShenYu was donated to the Apache Software Foundation, which was fully approved by the Apache Foundation and successfully entered the incubator.

Apache Dubbo

Apache Dubbo is a microservices development framework that provides two key capabilities: RPC communication and microservice governance. This means that microservices developed using Dubbo will have remote discovery and communication capabilities among themselves, while utilizing the rich service governance capabilities provided by Dubbo to implement service governance requirements such as service discovery, load balancing, and traffic scheduling. Additionally, Dubbo is highly extensible, allowing users to customize their implementations at almost any function point to change the default behavior of the framework to meet their business needs.

Using Apache Skywalking (Incubator) for Distributed Tracing

Sun, 11 Aug 2019 00:00:00 +0000

Introduction to Apache Skywalking (Incubator)

Apache Skywalking (Incubator) is an APM system designed for microservice architecture and cloud-native architecture systems that supports distributed tracing. Apache Skywalking (Incubator) collects application call chain information by loading probes and analyzes the collected call chain information to generate relationships and service metrics between applications and services. Currently, Apache Skywalking (Incubating) supports multiple languages, including Java, .Net Core, Node.js, and Go.

Skywalking currently supports dissecting the operation of distributed systems from six visualization dimensions. The overview view provides a global view of applications and components, including the number of components and applications, alarm fluctuations, slow service lists, and application throughput; the topology map shows the entire application’s topology based on application dependencies; the application view shows upstream and downstream relationships, TopN services, JVM-related information, and corresponding host information from the perspective of a single application. The service view focuses on the operating status of a single service entry and its upstream and downstream dependencies, helping users optimize and monitor individual services; the call chain shows all points of interest along with the execution duration of each point for a single request; the alarm view provides real-time alerts for applications, servers, and services based on configured thresholds.

When Dubbo Meets Arthas: Problem Diagnosis in Practice

Sat, 02 Feb 2019 00:00:00 +0000

Apache Dubbo is Alibaba’s open-source high-performance RPC framework with a large user base in China.

Github: https://github.com/apache/dubbo
Documentation: http://dubbo.apache.org/en-us/

Arthas is Alibaba’s open-source application diagnosis tool, which has gained over 6000 stars on Github within three months of its release in September.

Github: https://github.com/alibaba/arthas
Documentation: https://arthas.aliyun.com/doc/
Arthas open-source exchange QQ Group: 916328269
Arthas open-source exchange DingTalk Group: 21965291

What sparks will fly when Dubbo meets Arthas? Here are some experiences in diagnosing Dubbo issues using Arthas.

How to Use Seata to Ensure Consistency Between Dubbo Microservices

Thu, 17 Jan 2019 00:00:00 +0000

Case

The user purchases product business, which consists of 3 microservices:

Inventory Service: Deducts the inventory quantity of the given product.
Order Service: Generates an order based on the purchase request.
Account Service: Deducts from the user’s account balance.

Business Structure Diagram

StorageService

public interface StorageService {

 /**
 * Deduct storage quantity
 */
 void deduct(String commodityCode, int count);
}

OrderService

public interface OrderService {

 /**
 * Create order
 */
 Order create(String userId, String commodityCode, int orderCount);
}

AccountService

public interface AccountService {

 /**
 * Debit from user account
 */
 void debit(String userId, int money);
}

Main Business Logic:

public class BusinessServiceImpl implements BusinessService {

 private StorageService storageService;

 private OrderService orderService;

 /**
 * Purchase
 */
 public void purchase(String userId, String commodityCode, int orderCount) {

 storageService.deduct(commodityCode, orderCount);

 orderService.create(userId, commodityCode, orderCount);
 }
}

public class StorageServiceImpl implements StorageService {

 private StorageDAO storageDAO;
 
 @Override
 public void deduct(String commodityCode, int count) {
 Storage storage = new Storage();
 storage.setCount(count);
 storage.setCommodityCode(commodityCode);
 storageDAO.update(storage);
 }
}

public class OrderServiceImpl implements OrderService {

 private OrderDAO orderDAO;

 private AccountService accountService;

 public Order create(String userId, String commodityCode, int orderCount) {

 int orderMoney = calculate(commodityCode, orderCount);

 accountService.debit(userId, orderMoney);

 Order order = new Order();
 order.userId = userId;
 order.commodityCode = commodityCode;
 order.count = orderCount;
 order.money = orderMoney;

 return orderDAO.insert(order);
 }
}

Seata Distributed Transaction Solution

Introduction to the New Dubbo Admin

Mon, 07 Jan 2019 00:00:00 +0000

github: https://github.com/apache/dubbo-ops

The previous versions of Dubbo Admin were outdated and lacked maintenance for a long time. Therefore, a major refactoring of the project was carried out mid last year, with the following structural changes:

The backend framework was replaced from webx to spring boot.
The frontend uses Vue and Vuetify.js as the development framework.
Removed velocity templates.
Integrated swagger for API management features.

The current version of Dubbo Admin includes most of the functions from previous versions, including service governance and service query, while supporting the new service governance features introduced in Dubbo 2.7.

The Practice of Dubbo at Guazi Used Car

Sat, 05 Jan 2019 00:00:00 +0000

Preface

With the continuous development of Guazi’s business, the system scale is gradually expanding. Currently, hundreds of Dubbo applications and thousands of Dubbo instances are running on Guazi’s private cloud. Each department of Guazi has rapidly developed its own versions without timely alignment. With the construction of the second data center, the need for a unified Dubbo version has become increasingly urgent. A few months ago, a production incident related to Dubbo occurred, which became a catalyst for the company’s Dubbo version upgrade.

Dubbo Integrates Nacos as a Registry Center

Wed, 07 Nov 2018 00:00:00 +0000

Nacos is an important registry center implementation in the Dubbo ecosystem, and dubbo-registry-nacos is the implementation for integrating Nacos as a registry center in Dubbo.

Preparations

Before integrating dubbo-registry-nacos into your Dubbo project, make sure that the Nacos service is started in the background. If you are not familiar with the basic usage of Nacos, you can refer to the Nacos Quick Start. It is recommended to use Nacos version 0.6.1 or above.

Quick Integration of Dubbo + Hystrix in Spring Applications

Wed, 22 Aug 2018 00:00:00 +0000

Background

Hystrix is designed to provide more robust fault tolerance by controlling the nodes that access remote systems, services, and third-party libraries, thus providing stronger resilience against latency and failures. Hystrix includes thread and signal isolation, fallback mechanisms, circuit breaker functionality, request caching, request bundling, as well as monitoring and configuration.

Dubbo is an open-source Java RPC framework from Alibaba and is currently the most popular in China.

This article describes how to combine Dubbo and Hystrix in a Spring application.

From Cross-Language Calls to dubbo2.js

Tue, 14 Aug 2018 00:00:00 +0000

dubbo2.js is a Node.js Dubbo client contributed by Qianmi to the Dubbo community. It provides support for the native Dubbo protocol in Node.js, making RPC calls between Node.js and Java, two heterogeneous languages, convenient and efficient.

Cross-Language Calls in Microservices

Microservice architecture has become the trend in today’s internet architecture, and discussions about microservices occupy most of the various technical conferences. The most widely used service governance framework in China is undoubtedly Dubbo, an open-source project from Alibaba. Qianmi has also chosen Dubbo as its microservice governance framework. On the other hand, like most internet companies, Qianmi has a diverse range of development languages, with most backend services supported by Java, while each business line has the freedom to choose its own development language, leading to issues of calling Node.js, Python, and Go in a multi-language environment. Cross-language invocation is a broad and challenging topic, and several solutions frequently mentioned in the industry are as follows:

Using Zookeeper in Dubbo Applications

Tue, 07 Aug 2018 00:00:00 +0000

Introduction to Zookeeper

Basic Concepts

In modern distributed applications, coordination issues often arise between nodes, including leader election, cluster management, distributed locks, distributed configuration management, unified naming services, and state synchronization. Apache Zookeeper, as its name suggests, is a distributed coordination service framework designed to address these concerns.

To ensure high availability, ZooKeeper can be deployed in a cluster mode, known as a ZooKeeper ensemble. Within a ZooKeeper cluster, one node always acts as the leader, and through the ZAB (Zookeeper Atomic Broadcast Protocol) ¹ protocol, it ensures the consistency of information across all nodes. Clients can access any node in the cluster for read and write operations without worrying about data inconsistency.

Sentinel Safeguarding Dubbo Services

Fri, 27 Jul 2018 00:00:00 +0000

In complex production environments, thousands of Dubbo service instances may be deployed, with continuous traffic flowing in and services calling each other. However, distributed systems may encounter issues like traffic surges, system overload, and network delays, leading to service unavailability. If not controlled, this may cause cascading failures, impacting service availability. Hence, the rational control of traffic becomes key to ensuring service stability.

Sentinel is an open-source lightweight traffic control product developed by Alibaba’s middleware team, focusing on traffic dynamics and helping users protect service stability through traffic control, circuit breaking, and system load protection. This article will explore how Sentinel performs traffic control based on Dubbo, providing best practices for Dubbo integration with Sentinel.

Using Pinpoint for Distributed Tracing

Thu, 12 Jul 2018 00:00:00 +0000

When using Dubbo for service-oriented or integrated applications, if a service’s backend logs show an exception, and this service is called by multiple applications, it is often difficult to determine which application made the call and what the cause of the issue is. Thus, we need a distributed tracing system to quickly locate the problem, and Pinpoint can help us achieve this (of course, there are other solutions as well).

Using Zipkin in Dubbo

Sun, 17 Jun 2018 00:00:00 +0000

As business grows, the scale of applications continues to expand, and traditional application architectures cannot meet demands. The transformation to a service-oriented architecture is imperative, with distributed service frameworks like Dubbo becoming essential. As the microservices concept becomes widely accepted, applications are further segmented into finer granularity, and different applications are independently managed by various development teams, resulting in a very complex distributed system. No one can clearly and timely know the overall dependency relationships within the system. When problems occur, it’s also not possible to quickly identify which link in the chain fails.