Why Alibaba’s Open‑Source Sentinel Beats Other Service Rate‑Limiting Tools

Background

Microservice architectures often involve long call chains, and a single service failure can cascade into a system‑wide outage. Implementing a protection mechanism that limits traffic, performs circuit breaking, and guards against overload is therefore essential for stable microservice operation.

What Is Sentinel?

Sentinel is an open‑source traffic‑governance component from Alibaba that provides flow control, circuit breaking, system overload protection, and hotspot traffic defense. It operates at the traffic level and helps developers ensure the stability of distributed services.

Sentinel vs. Hystrix

Hystrix, the first generation circuit‑breaker used in Spring Cloud, can trigger fallback when a remote call fails repeatedly. However, Hystrix supports only a limited set of degradation dimensions and lacks fine‑grained flow‑control capabilities. Sentinel extends the feature set by supporting both circuit breaking and precise rate limiting for individual methods.

Quick Start

Add the core Sentinel dependency to your Maven project:

<dependency>
  <groupId>com.alibaba.csp</groupId>
  <artifactId>sentinel-core</artifactId>
  <version>1.7.1</version>
</dependency>

Define a flow‑rule initialization method:

private static void initFlowRules() {
    List<FlowRule> rules = new ArrayList<>();
    FlowRule rule = new FlowRule();
    // Add the rule to be limited
    rule.setResource("hello");
    rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    // Set the QPS limit to 5 requests per second
    rule.setCount(5);
    rules.add(rule);
    FlowRuleManager.loadRules(rules);
}

Wrap the protected code with SphU.entry() and entry.exit():

public static void main(String[] args) throws Exception {
    initFlowRules();
    for (int i = 1; i < 10; i++) {
        Entry entry = null;
        try {
            // Open the flow control or circuit‑break protection
            entry = SphU.entry("hello");
            System.out.println("Iteration " + i + ": hello world");
        } catch (BlockException e) {
            System.out.println("Iteration " + i + ": request too frequent, rate‑limited!");
        } catch (Exception e) {
            Tracer.traceEntry(e, entry);
            System.out.println("Iteration " + i + ": exception occurred, fallback!");
        } finally {
            if (entry != null) {
                entry.exit();
            }
        }
    }
}

Running the program prints normal messages for the first five calls and rate‑limited messages thereafter, confirming the QPS limit.

SpringBoot Integration

Create a Maven project (e.g., alibaba-sentinel-client) and add the following dependencies:

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <spring-boot.version>2.2.5.RELEASE</spring-boot.version>
    <spring-cloud.version>Hoxton.SR3</spring-cloud.version>
    <spring-cloud-alibaba.version>2.2.1.RELEASE</spring-cloud-alibaba.version>
</properties>

<dependencies>
    <!-- SpringBoot web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Service flow control and circuit breaking: Sentinel -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <!-- SpringBoot version -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!-- Spring Cloud version -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!-- Spring Cloud Alibaba version -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Define a flow‑rule initialization method similar to the quick‑start example, then create a REST controller that uses the rule:

@RestController
public class HelloController {
    @SentinelResource(value = "hello", blockHandler = "blockCallBack", fallback = "failCallBack")
    @GetMapping("/hello")
    public String hello(@RequestParam(value = "name", required = false) String name) {
        if (StringUtils.isEmpty(name)) {
            throw new RuntimeException("name is null");
        }
        return "hello, received param: " + name;
    }

    // Block handler – executed when rate limiting occurs
    public String blockCallBack(String name, BlockException ex) {
        ex.printStackTrace();
        return "[Rate‑limited] Too many requests, please try later! Param: " + name;
    }

    // Fallback – executed when an exception occurs
    public String failCallBack(String name, Throwable ex) {
        ex.printStackTrace();
        return "[Fallback] System error, please retry later!";
    }
}

If you prefer a non‑intrusive approach, the built‑in @SentinelResource annotation can replace the manual try‑catch‑finally pattern.

Register the Sentinel AOP proxy so that the annotation takes effect:

@Configuration
public class SentinelAspectConfiguration {
    @Bean
    public SentinelResourceAspect sentinelResourceAspect() {
        return new SentinelResourceAspect();
    }
}

Sentinel Dashboard

Download the dashboard JAR from the official repository (GitHub or Gitee) and start it:

java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -jar sentinel-dashboard.jar

Open http://localhost:8080 and log in with username and password both set to sentinel. The UI shows menus such as cluster‑link, flow‑control rules, and degradation rules.

Client Connection to the Dashboard

If you already depend on spring-cloud-starter-alibaba-sentinel, the transport module is included automatically. Otherwise, add the simple‑http transport dependency:

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-transport-simple-http</artifactId>
</dependency>

Configure the dashboard address in application.properties:

spring.application.name=alibaba-sentinel-client
server.port=8002

# Sentinel dashboard address
spring.cloud.sentinel.transport.dashboard=localhost:8080

After restarting the application, the protected resources appear on the dashboard. You can click the resource name (e.g., hello) and set a QPS limit of 1 directly from the UI. Subsequent requests will be rate‑limited, and you can also define degradation rules (e.g., trigger fallback when exceptions exceed a threshold).

OpenFeign Adaptation

Enable Sentinel support for Feign by setting the following property: feign.sentinel.enabled=true Example Feign client with a fallback implementation:

@FeignClient(name = "service-provider", fallback = EchoServiceFallback.class)
public interface EchoService {
    @GetMapping("/hello/{name}")
    String hello(@PathVariable("name") String name);
}

@Component
class EchoServiceFallback implements EchoService {
    @Override
    public String hello(String name) {
        return "Service automatically degraded...";
    }
}

Other Rule Types

Beyond flow‑control rules, Sentinel also offers hotspot rules, system rules, and authorization rules. Refer to the official documentation for detailed usage.

References

https://sca.aliyun.com/docs/2.2.x/user-guide/sentinel/overview

https://developer.aliyun.com/article/783342

https://sentinelguard.io/zh-cn/docs/introduction.html