Introduction to Alibaba Sentinel

1. Overview

As the name suggests, Sentinel is a powerful guard for microservices. It offers features like flow control, concurrency limiting, circuit breaking, and adaptive system protection to guarantee their reliability. It's an open-source component actively maintained by Alibaba Group. In addition, it's officially a part of the Spring Cloud Circuit Breaker.

In this tutorial, we'll have a look at some of Sentinel's main features. Further, we'll see an example of how to use it, its annotation support, and its monitoring dashboard.

2. Features

2.1. Flow Control

Sentinel controls the speed of random incoming requests to avoid the overloading of microservices. This ensures that our service isn't killed by a surge in traffic. It supports a variety of traffic shaping strategies. These strategies automatically adjust traffic to appropriate shapes when Queries per Second (QPS) is too high.

Some of these traffic shaping strategies are:

• Direct Rejection Mode – When the number of requests per second exceeds the set threshold, it'll automatically reject further requests
• Slow Start Warm-Up Mode – If there's a sudden surge in traffic, this mode ensures that the request count goes on increasing gradually, until reaching the upper limit

2.2. Circuit Breaking and Downgrade

When one service synchronously calls another, there's a possibility that another service can be down for some reason. In such a case, threads are blocked as they keep on waiting for the other service to respond. This can lead to resource exhaustion and the caller service will also be unable to handle further requests. This is called a cascading effect and can take down our entire microservices architecture.

To prevent such scenarios, a circuit breaker comes into the picture. It will block all subsequent calls to the other service immediately. After the timeout period, some requests are passed through. If they succeed, then the circuit breaker resumes normal flow. Otherwise, the timeout period starts again.

Sentinel uses the principle of max concurrency limiting to implement circuit breaking. It reduces the impact of unstable resources by restricting the number of concurrent threads.

Sentinel also downgrades unstable resources. All calls to the resource will be rejected in the specified time window when the response time of a resource is too high. This prevents situations where calls become very slow, leading to the cascading effect.

2.3. Adaptive System Protection

Sentinel protects our server in case the system load goes too high. It uses load1 (system load) as the metric to initiate traffic control. The request will be blocked under the following conditions:

• Current system load (load1) > threshold (highestSystemLoad);
• Current concurrent requests (thread count) > estimated capacity (min response time * max QPS)

3. How to Use

3.1. Add Maven Dependency

In our Maven project, we need to add the sentinel-core dependency in the pom.xml:

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

3.2. Define Resource

Let's define our resource with the corresponding business logic inside a try-catch block using the Sentinel API:

try (Entry entry = SphU.entry("HelloWorld")) {
    // Our business logic here.
    System.out.println("hello world");
} catch (BlockException e) {
    // Handle rejected request.
}

This try-catch block with the resource name “HelloWorld”, serves as the entry point to our business logic, guarded by Sentinel.

3.3. Define Flow Control Rules

These rules control the flow to our resource, like threshold count or control behavior — for example, reject directly or slow startup. Let's use FlowRuleManager.loadRules() to configure the flow rules:

List<FlowRule> flowRules = new ArrayList<>();
FlowRule flowRule = new FlowRule();
flowRule.setResource(RESOURCE_NAME);
flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
flowRule.setCount(1);
flowRules.add(flowRule);
FlowRuleManager.loadRules(flowRules);

This rule defines that our resource “RESOURCE_NAME” can respond to a maximum of one request per second.

3.4. Defining Degrade Rules

Using degrade rules, we can configure the circuit breaker's threshold request count, recovery timeout, and other settings.
Let's configure the degrade rules using DegradeRuleManager.loadRules():

List<DegradeRule> rules = new ArrayList<DegradeRule>();
DegradeRule rule = new DegradeRule();
rule.setResource(RESOURCE_NAME);
rule.setCount(10);
rule.setTimeWindow(10);
rules.add(rule);
DegradeRuleManager.loadRules(rules);

This rule specifies that when our resource RESOURCE_NAME fails to serve 10 requests (threshold count), the circuit will break. All subsequent requests to the resource will be blocked by Sentinel for 10 seconds (time window).

3.5. Defining System Protection Rules

Using system protection rules, we can configure and ensure adaptive system protection (threshold of load1, average response time, concurrent thread count). Let's configure the system rules using the SystemRuleManager.loadRules() method:

List<SystemRule> rules = new ArrayList<>();
SystemRule rule = new SystemRule();
rule.setHighestSystemLoad(10);
rules.add(rule);
SystemRuleManager.loadRules(rules);

This rule specifies that, for our system, the highest system load is 10 requests per second. All further requests will be blocked if the current load goes beyond this threshold.

4. Annotation Support

Sentinel also provides aspect-oriented annotation support for defining the resource.

First, we'll add the Maven dependency for sentinel-annotation-aspectj:

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-annotation-aspectj</artifactId>
    <version>1.8.0</version>
</dependency>

Then, we add @Configuration to our configuration class to register the sentinel aspect as a Spring bean:

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

@SentinelResource indicates the resource definition. It has attributes like value, which defines the resource name. Attribute fallback is the fallback method name. When the circuit is broken, this fallback method defines the alternate flow of our program. Let's define the resource using the @SentinelResource annotation:

@SentinelResource(value = "resource_name", fallback = "doFallback")
public String doSomething(long i) {
    return "Hello " + i;
}
public String doFallback(long i, Throwable t) {
    // Return fallback value.
    return "fallback";
}

This defines the resource with the name resource_name, as well as the fallback method.

5. Monitoring Dashboard

Sentinel also provides a monitoring dashboard. With this, we can monitor the clients and configure the rules dynamically. We can see the amount of incoming traffic to our defined resources in real-time.

5.1. Starting the Dashboard

First, we need to download the Sentinel Dashboard jar. And then, we can start the dashboard using the command:

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

Once the dashboard application starts up, we can connect our application following the steps in the next sections.

5.2. Preparing Our Application

Let's add the sentinel-transport-simple-http dependency to our pom.xml:

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

5.3. Connecting Our Application to the Dashboard

When starting the application, we need to add the dashboard IP address:

-Dcsp.sentinel.dashboard.server=consoleIp:port

Now, whenever a resource is called, the dashboard will receive the heartbeat from our application:

We can also manipulate the flow, degrade, and system rules dynamically using the dashboard.

6. Conclusion

In this article, we saw the main features of Alibaba Sentinel flow control, circuit breaker, and adaptive system protection.

Corresponding examples can be found over on GitHub.