Microservice Architecture and DevOps Practices at RongShu Data

Microservices are defined as clearly bounded, highly encapsulated, loosely coupled services that can be independently deployed and scaled. Built on SOA and Domain‑Driven Design, they aim to improve development agility, deployment convenience, and clear scalability.

The article compares microservices with traditional SOA, noting that while microservices follow SOA design principles, they emphasize independent development, deployment, and scaling, and discourage heavy code‑level API exposure in favor of service calls or events.

Key advantages of microservices include increased agility, reduced deployment risk, suitability for distributed development, technical flexibility (allowing different languages per service), and independent scalability.

Design considerations discuss service granularity: too fine‑grained leads to excessive orchestration, while too coarse reduces agility. The architecture adopts Domain‑Driven Design concepts such as Bounded Context, Context Map, Event Sourcing, CQRS, and BASE.

RongShu Data’s microservice architecture selection follows principles of reusing existing frameworks, minimizing impact on current development practices, and supporting multi‑protocol, multi‑language, and monitoring capabilities. After evaluating open‑source frameworks, the team chose to evolve from a RESTEasy + Spring Boot stack to a gRPC‑based solution wrapped in a custom framework.

Major refactoring steps include:

Encapsulating gRPC in a Service Provider layer to replace REST services.

Using a Proxy to translate between gRPC and REST, preserving compatibility.

Moving to decentralized governance via Proxy‑based endpoint management.

Integrating Zipkin for tracing and Pinpoint for APM monitoring.

Implementing semantic versioning (major.minor.patch) with optional pre‑release identifiers.

Sample service implementation (Java) is shown below:

//服务提供方
public class SmsTemplateApplication {
    public static void main(String[] args) {
        new SpringApplicationBuilder()
            .sources(SmsTemplateApplication.class)
            .web(false).showBanner(false).run(args);
    }
}

//服务实现
public class SmsTempletServiceImpl implements SmsTemplateService {
    @Autowired
    private SmsTempletDao smsTempletDao;
    @Transactional
    public DeleteReply deleteById(IdRequest req) {
        return SmsTemplateReply.newBuilder().build();
    }
}

The overall design emphasizes DevOps‑friendly features: lifecycle‑managed endpoints, configuration‑code separation, containerized deployment APIs, and support for Java, Python, and Go.

Key architectural traits of the Graeae framework include protocol‑agnostic design, Netty4‑based performance optimizations, Protocol Buffers for efficient serialization, language neutrality, built‑in circuit breaking, flow control, and distributed governance via Proxy and PaaS platforms.

Endpoints follow a responsibility‑chain pattern to wrap gRPC calls, providing synchronous invocation for easier migration. Configuration can be overridden without redeployment, and the framework integrates with Spring Boot for rapid service startup.

The DevOps platform builds binary packages, enriches them with metadata to form logical packages, stores all metadata centrally, and deploys services based on logical environments. Proxies expose VIPs for service discovery, while Zipkin and an inventory service capture call‑graph information for distributed governance.

Team organization follows a two‑pizza, full‑stack model aligned with business domains, promoting direct communication between developers and product owners, result‑oriented work, on‑call responsibilities, and continuous improvement of service reliability.

In conclusion, the adoption of microservices at RongShu Data is supported by a cloud‑native architecture, comprehensive DevOps tooling, and a culture that bridges development and operations to achieve high‑efficiency, end‑to‑end delivery.