Comprehensive Guide to Sentinel: Flow Control, Rate Limiting, Circuit Breaking, and Monitoring for Microservices

Sentinel

Sentinel is an Alibaba‑developed traffic‑control component that serves as a core part of Spring Cloud Alibaba for building microservices. It provides flow control, circuit breaking, real‑time monitoring, and system protection to ensure stability and availability of distributed systems.

Principles

The core capabilities of Sentinel include traffic limiting, circuit breaking (degradation), real‑time monitoring, and overall system protection.

Flow Control

Flow control (rate limiting) restricts incoming requests to prevent overload. Sentinel offers multiple limiting strategies such as QPS‑based limits, thread‑count limits, and hotspot‑parameter limits.

Common rate‑limiting algorithms:

Fixed Window Counter: divides time into fixed windows and counts requests per window.

Sliding Window Log: records timestamps of each request and counts those within the sliding window.

Leaky Bucket: places requests into a bucket that drains at a fixed rate, discarding excess requests.

Example implementation of the Leaky Bucket algorithm:

public class LeakyBucket {
    private int water = 0; // current water amount in the bucket
    private final int capacity; // bucket capacity
    private final int leakRate; // leak rate per millisecond
    private long lastLeakTime = System.currentTimeMillis();

    public LeakyBucket(int capacity, int leakRate) {
        this.capacity = capacity;
        this.leakRate = leakRate;
    }

    public synchronized boolean allowRequest() {
        long now = System.currentTimeMillis();
        long leakedWater = (now - lastLeakTime) * leakRate;
        water = Math.max(0, water - (int) leakedWater);
        lastLeakTime = now;
        if (water < capacity) {
            water++;
            return true;
        } else {
            return false;
        }
    }
}

Circuit Breaking (Degradation)

When a resource becomes unstable or unavailable, circuit breaking temporarily stops calls to prevent fault propagation. Sentinel provides several common rules:

Response Time (RT) Breaker: triggers when the average response time exceeds a threshold for a sustained period (e.g., >500 ms for 1 minute).

Exception Ratio Breaker: triggers when the exception ratio exceeds a threshold for a sustained period (e.g., >50 % for 1 minute).

Exception Count Breaker: triggers when the number of exceptions within a time window exceeds a threshold (e.g., >100 exceptions in 1 minute).

Real‑time Monitoring and Statistics

Sentinel also offers detailed real‑time monitoring and statistical dashboards, helping developers understand system health, traffic patterns, and rule effectiveness. The Sentinel console visualizes these metrics and allows rule management.

Using Sentinel

1. Add Maven Dependency

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

2. Configure Rules

Programmatic configuration example:

DegradeRule rule = new DegradeRule();
rule.setResource("someResource");
rule.setGrade(RuleConstant.DEGRADE_GRADE_RT);
rule.setCount(500); // average RT threshold (ms)
rule.setTimeWindow(60); // break duration (seconds)
DegradeRuleManager.loadRules(Collections.singletonList(rule));

Annotation‑based configuration example:

@SentinelResource(value = "someResource", blockHandler = "handleBlock", fallback = "fallback")
public String someMethod() {
    // business logic
    return "success";
}

public String handleBlock(BlockException ex) {
    return "request blocked";
}

public String fallback(Throwable ex) {
    return "service degraded";
}

3. Run Monitoring

The Sentinel console displays real‑time traffic data and system status, enabling quick detection and resolution of issues.

Conclusion

Sentinel provides three main rate‑limiting algorithms—Fixed Window Counter (simple but suffers from boundary issues), Sliding Window Log (solves boundary problems but uses more memory), and Leaky Bucket (smooths traffic flow with slightly higher complexity). It also offers flexible circuit‑breaking rules and a powerful monitoring console for microservice resilience.

At the end of the article, the author shares links to a 300k‑word architecture collection and a comprehensive Java interview Q&A set, inviting readers to obtain them via WeChat.