Mastering Sentinel: A Deep Dive into Alibaba’s Traffic Governance Engine

Sentinel Overview

Sentinel is an open‑source traffic‑governance component from Alibaba designed for distributed, heterogeneous service architectures. It provides flow routing, flow control, shaping, circuit breaking, system adaptive overload protection, and hotspot traffic defense to ensure microservice stability.

Core Concepts

Resource

A resource is the object protected by Sentinel, typically an HTTP or RPC interface identified by its request path.

Rule

Rules define the conditions for limiting a resource, such as flow‑control, circuit‑breaking, or system protection rules.

Demo

Basic usage example with Maven dependency and Java code.

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

public class SentinelSimpleDemo {
    public static void main(String[] args) {
        // Load flow rules
        initFlowRules();
        for (int i = 0; i < 5; i++) {
            Entry entry = null;
            try {
                entry = SphU.entry("sayHello");
                // Protected logic
                System.out.println("访问sayHello资源");
            } catch (BlockException ex) {
                System.out.println("被流量控制了，可以进行降级处理");
            } finally {
                if (entry != null) {
                    entry.exit();
                }
            }
        }
    }

    private static void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        // Create a flow rule
        FlowRule rule = new FlowRule();
        // Limit the sayHello resource
        rule.setResource("sayHello");
        // QPS based limiting
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // Max QPS = 2
        rule.setCount(2);
        rules.add(rule);
        // Load rules
        FlowRuleManager.loadRules(rules);
    }
}

initFlowRules loads a flow rule for the sayHello resource with a QPS limit of 2. SphU.entry("sayHello") checks the rule before executing protected logic.

Catching BlockException indicates the request was limited.

The print statement shows the protected resource access.

Test results show that after two successful accesses the QPS reaches 2 and subsequent calls are blocked.

Spring Integration

Integrate Sentinel with Spring Boot by adding dependencies and defining a /sayHello endpoint.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    <version>2.2.5.RELEASE</version>
</dependency>

@RestController
public class SentinelDemoController {
    @GetMapping("/sayHello")
    public String sayHello() throws InterruptedException {
        return "hello";
    }
}

Configure the Sentinel dashboard address in the application configuration to enable dynamic rule management.

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080

Core Principles

Sentinel creates a single ProcessorSlot chain per resource. The SphU.entry(..) call traverses this chain to enforce rules.

Processor Slots

NodeSelectorSlot – selects the statistics node for the current entry.

ClusterBuilderSlot – builds cluster and origin nodes for aggregated and caller‑specific statistics.

LogSlot – logs exceptions.

StatisticSlot – updates statistics such as QPS and thread count.

AuthoritySlot – performs whitelist/blacklist authorization.

SystemSlot – limits based on system metrics like CPU and load.

FlowSlot – enforces flow‑control rules.

DegradeSlot – handles circuit‑breaking based on slow‑call ratio, exception ratio, or count.

These slots are loaded via SPI and ordered to form the processing chain.

Sentinel also supports multi‑entry and origin concepts, allowing separate statistics for different callers or entry points.

Summary

Sentinel’s power lies in its statistical nodes and the chain of processor slots that implement flow control and circuit breaking, offering a lightweight yet extensible solution for microservice stability.