Ali-Sentinel-链路控制

已于 2024-05-09 11:42:59 修改
阅读量552 收藏 4
点赞数 3
分类专栏： 源码 文章标签： java sentinel
于 2024-04-26 18:07:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fl_zxf/article/details/138226511
版权

归档

链结构

具体实现

NodeSelectorSlot

  • 给上下文设置统计节点

  • com.alibaba.csp.sentinel.slots.nodeselector.NodeSelectorSlot

@Spi(isSingleton = false, order = Constants.ORDER_NODE_SELECTOR_SLOT)
public class NodeSelectorSlot extends AbstractLinkedProcessorSlot<Object> {

    private volatile Map<String, DefaultNode> map = new HashMap<String, DefaultNode>(10);

    @Override
    public void entry(
        Context context, ResourceWrapper resourceWrapper, Object obj, int count, boolean prioritized, Object... args
    ) throws Throwable {
        DefaultNode node = map.get(context.getName());
        if (node == null) {
            synchronized (this) {   // DCL
                node = map.get(context.getName());
                if (node == null) {
                    node = new DefaultNode(resourceWrapper, null);              // 创建默认节点
                    HashMap<String, DefaultNode> cacheMap = new HashMap<String, DefaultNode>(map.size());
                    cacheMap.putAll(map);
                    cacheMap.put(context.getName(), node);
                    map = cacheMap;                                             // COW
                    ((DefaultNode) context.getLastNode()).addChild(node);       // 构建调用树  ref: sign_m_010 | sign_m_020
                }
            }
        }

        context.setCurNode(node);                                               // 保存到上下文  ref: sign_m_011
        fireEntry(context, resourceWrapper, node, count, prioritized, args);    // (将统计节点) 流转给下游
    }
}

    // sign_m_010 获取尾节点
    public Node getLastNode() {
        if (curEntry != null && curEntry.getLastNode() != null) {
            return curEntry.getLastNode();  // sign_m_040
        } else {
            return entranceNode;    // 一般返回此
        }
    }

    // sign_m_011
    public Context setCurNode(Node node) {
        this.curEntry.setCurNode(node); //  sign_m_030
        return this;
    }
  • com.alibaba.csp.sentinel.node.DefaultNode
    // sign_m_020 添加子节点
    public void addChild(Node node) {
        ... // 省略 node 空判断
        if (!childList.contains(node)) {
            synchronized (this) {       // DCL
                if (!childList.contains(node)) {
                    Set<Node> newSet = new HashSet<>(childList.size() + 1);
                    newSet.addAll(childList);
                    newSet.add(node);
                    childList = newSet; // COW
                }
            }
        }
    }
  • com.alibaba.csp.sentinel.Entry

    public abstract Node getLastNode();

    // sign_m_030
    public void setCurNode(Node node) {
        this.curNode = node;
    }

    // sign_m_031
    public Node getCurNode() {
        return curNode;
    }
  • com.alibaba.csp.sentinel.CtEntry
    // sign_m_040
    @Override
    public Node getLastNode() {
        return parent == null ? null : parent.getCurNode(); // sign_m_031
    }

ClusterBuilderSlot

  • 给统计节点设置集群(统计)节点

    • 只是用于统计

  • com.alibaba.csp.sentinel.slots.clusterbuilder.ClusterBuilderSlot

@Spi(isSingleton = false, order = Constants.ORDER_CLUSTER_BUILDER_SLOT)
public class ClusterBuilderSlot extends AbstractLinkedProcessorSlot<DefaultNode> {

    private static volatile Map<ResourceWrapper, ClusterNode> clusterNodeMap = new HashMap<>(); // 记录所有的节点
    private static final Object lock = new Object();
    private volatile ClusterNode clusterNode = null;

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable 
    {
        if (clusterNode == null) {
            synchronized (lock) {   // DCL
                if (clusterNode == null) {
                    clusterNode = new ClusterNode(resourceWrapper.getName(), resourceWrapper.getResourceType());
                    HashMap<ResourceWrapper, ClusterNode> newMap = new HashMap<>(Math.max(clusterNodeMap.size(), 16));
                    newMap.putAll(clusterNodeMap);
                    newMap.put(node.getId(), clusterNode);
                    clusterNodeMap = newMap;    // COW
                }
            }
        }
        node.setClusterNode(clusterNode);       // 设置集群节点

        ... // 省略设置源节点处理

        fireEntry(context, resourceWrapper, node, count, prioritized, args);    // 传递给下游节点
    }

}

LogSlot

  • 日志异常记录

  • com.alibaba.csp.sentinel.slots.logger.LogSlot

@Spi(order = Constants.ORDER_LOG_SLOT)
public class LogSlot extends AbstractLinkedProcessorSlot<DefaultNode> {

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode obj, int count, boolean prioritized, Object... args)
        throws Throwable 
    {
        try {
            fireEntry(context, resourceWrapper, obj, count, prioritized, args); // 先传给下游
        } catch (BlockException e) {
            EagleEyeLogUtil.log(resourceWrapper.getName(), e.getClass().getSimpleName(), e.getRuleLimitApp(),
                context.getOrigin(), e.getRule().getId(), count);
            throw e; // 继续往上抛
        } catch (Throwable e) {
            // 下游处理出错，则记录异常日志
            RecordLog.warn("Unexpected entry exception", e);
        }
    }
}

StatisticSlot

  • 统计各种数据

  • com.alibaba.csp.sentinel.slots.statistic.StatisticSlot

@Spi(order = Constants.ORDER_STATISTIC_SLOT)
public class StatisticSlot extends AbstractLinkedProcessorSlot<DefaultNode> {

    @Override // sign_m_400 记录通过数
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable 
    {
        try {
            /**
             * 先传给下游处理，让下游先处理，
             * 后面自己才做统计，
             * 这样，下游要处理 QPS 等，要等下次才有数据
             */
            fireEntry(context, resourceWrapper, node, count, prioritized, args);

            // 添加线程计数和通过计数
            node.increaseThreadNum();
            node.addPassRequest(count);                     // ref: sign_m_401

            ... // 省略入口源节点添加计数

            // 全局入站节点添加计数 (其用于系统流控)
            if (resourceWrapper.getEntryType() == EntryType.IN) {
                Constants.ENTRY_NODE.increaseThreadNum();
                Constants.ENTRY_NODE.addPassRequest(count); // ref: sign_m_401
            }

            ... // sign_call_100 省略注册的回调器处理
        } catch (PriorityWaitException ex) {
            ... // 省略此异常处理 (相当于下游抛出此异常，上面的统计 (除 pass 外) 再走一次)
        } catch (BlockException e) {
            context.getCurEntry().setBlockError(e); // 记录异常
            node.increaseBlockQps(count);           // Add block count.
            
            ... // 省略入口源节点添加计数

            // 全局入站节点添加计数
            if (resourceWrapper.getEntryType() == EntryType.IN) {
                Constants.ENTRY_NODE.increaseBlockQps(count);
            }

            ... // 省略注册的回调器处理
            throw e;
        } catch (Throwable e) {
            context.getCurEntry().setError(e);      // 记录异常
            throw e;
        }
    }

    @Override // 记录完成数
    public void exit(Context context, ResourceWrapper resourceWrapper, int count, Object... args) {
        Node node = context.getCurNode();

        if (context.getCurEntry().getBlockError() == null) {
            // 计算响应时间 (当前时间 - 入口创建时间)
            long completeStatTime = TimeUtil.currentTimeMillis();
            context.getCurEntry().setCompleteTimestamp(completeStatTime);
            long rt = completeStatTime - context.getCurEntry().getCreateTimestamp();

            Throwable error = context.getCurEntry().getError();

            // 记录响应时间和成功次数
            recordCompleteFor(node, count, rt, error);
            recordCompleteFor(context.getCurEntry().getOriginNode(), count, rt, error);
            if (resourceWrapper.getEntryType() == EntryType.IN) {
                recordCompleteFor(Constants.ENTRY_NODE, count, rt, error);
            }
        }

        ... // sign_call_200 省略注册的回调器处理

        fireExit(context, resourceWrapper, count, args); // 传给下游
    }

    private void recordCompleteFor(Node node, int batchCount, long rt, Throwable error) {
        ... // 省略 node 为空返回处理
        node.addRtAndSuccess(rt, batchCount);       // 添加 RT 和完成数
        node.decreaseThreadNum();                   // 减线程数
        if (error != null && !(error instanceof BlockException)) {
            node.increaseExceptionQps(batchCount);  // 添加异常计数
        }
    }
}
  • com.alibaba.csp.sentinel.node.DefaultNode
    // sign_m_401
    @Override
    public void addPassRequest(int count) {
        super.addPassRequest(count);            // ref: sign_m_410
        this.clusterNode.addPassRequest(count); // ref: sign_m_410
    }

    // sign_m_410
    @Override
    public void addPassRequest(int count) {
        rollingCounterInSecond.addPass(count);  // 参考： 节点与度量-addpass
        rollingCounterInMinute.addPass(count);
    }

AuthoritySlot

  • 黑、白名单权限校验

  • com.alibaba.csp.sentinel.slots.block.authority.AuthoritySlot

@Spi(order = Constants.ORDER_AUTHORITY_SLOT)
public class AuthoritySlot extends AbstractLinkedProcessorSlot<DefaultNode> {
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count, boolean prioritized, Object... args)
        throws Throwable 
    {
        checkBlackWhiteAuthority(resourceWrapper, context);                     // 先校验  ref: sign_m_501
        fireEntry(context, resourceWrapper, node, count, prioritized, args);    // 再传给下游
    }

    // sign_m_501
    void checkBlackWhiteAuthority(ResourceWrapper resource, Context context) throws AuthorityException {
        Map<String, Set<AuthorityRule>> authorityRules = AuthorityRuleManager.getAuthorityRules();  // 获取总规则
        ... // 省略 authorityRules 为 null 返回

        Set<AuthorityRule> rules = authorityRules.get(resource.getName());  // 获取当前资源的规则
        ... // 省略 rules 为 null 返回

        // 一般一个资源只有一条规则  ref: AuthorityRuleManager.RulePropertyListener #loadAuthorityConf
        for (AuthorityRule rule : rules) {
            if (!AuthorityRuleChecker.passCheck(rule, context)) {           // 依次校验  ref: sign_m_510
                throw new AuthorityException(context.getOrigin(), rule);    // 校验不通过则抛异常
            }
        }
    }
}
  • com.alibaba.csp.sentinel.slots.block.authority.AuthorityRuleChecker
    // sign_m_510 校验权限规则
    static boolean passCheck(AuthorityRule rule, Context context) {
        String requester = context.getOrigin();

        ... // 省略 requester 和 rule.getLimitApp() 空判断

        int pos = rule.getLimitApp().indexOf(requester);
        boolean contain = pos > -1; // 包含

        // 加此判断可省略不包含时的多余处理
        // 下面的处理相当于：逗号分隔再依次精确匹配
        if (contain) {
            boolean exactlyMatch = false;
            String[] appArray = rule.getLimitApp().split(",");  // 英文逗号分隔
            for (String app : appArray) {
                if (requester.equals(app)) {    // 精确匹配
                    exactlyMatch = true;        // 匹配上，才算包含
                    break;
                }
            }
            contain = exactlyMatch;
        }

        int strategy = rule.getStrategy();
        if (strategy == RuleConstant.AUTHORITY_BLACK && contain) {  // 黑名单，包含：则不通过
            return false;
        }
        if (strategy == RuleConstant.AUTHORITY_WHITE && !contain) { // 白名单，不包含：则不通过
            return false;
        }
        return true;    // 通过
    }

SystemSlot

  • com.alibaba.csp.sentinel.slots.system.SystemSlot
@Spi(order = Constants.ORDER_SYSTEM_SLOT)
public class SystemSlot extends AbstractLinkedProcessorSlot<DefaultNode> {
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable 
    {
        SystemRuleManager.checkSystem(resourceWrapper, count);                  // 先校验  ref: sign_m_610
        fireEntry(context, resourceWrapper, node, count, prioritized, args);    // 再传给下游
    }
}
  • com.alibaba.csp.sentinel.slots.system.SystemRuleManager
    // sign_m_610
    public static void checkSystem(ResourceWrapper resourceWrapper, int count) throws BlockException {
        ... // 省略 resourceWrapper 为 null 返回
        ... // 省略 checkSystemStatus 为 false 返回
        ... // 省略 资源类型 不为 入站 返回

        // total qps
        double currentQps = Constants.ENTRY_NODE.passQps(); // 在 StatisticSlot 里记录，ref: sign_m_400
        if (currentQps + count > qps) {
            throw new SystemBlockException(resourceWrapper.getName(), "qps");
        }

        ... // 省略 线程数 校验
        ... // 省略 平均RT 校验

        // load. BBR algorithm.
        if (highestSystemLoadIsSet && getCurrentSystemAvgLoad() > highestSystemLoad) {
            if (!checkBbr(currentThread)) { // ref: sign_m_611
                throw new SystemBlockException(resourceWrapper.getName(), "load");
            }
        }

        ... // 省略 CPU 校验 (CPU 数据每秒读取一次)
    }

    // sign_m_611
    private static boolean checkBbr(int currentThread) {
        if (currentThread > 1 &&
            currentThread > Constants.ENTRY_NODE.maxSuccessQps() * Constants.ENTRY_NODE.minRt() / 1000) {
            return false;
        }
        return true;
    }

FlowSlot

@Spi(order = Constants.ORDER_FLOW_SLOT)
public class FlowSlot extends AbstractLinkedProcessorSlot<DefaultNode> {
    
    private final FlowRuleChecker checker;

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable 
    {
        checkFlow(resourceWrapper, context, node, count, prioritized);          // 先校验 sign_m_710
        fireEntry(context, resourceWrapper, node, count, prioritized, args);    // 再传给下游
    }

    // sign_m_710
    void checkFlow(ResourceWrapper resource, Context context, DefaultNode node, int count, boolean prioritized)
        throws BlockException 
    {
        checker.checkFlow(ruleProvider, resource, context, node, count, prioritized);   // sign_m_720
    }

    // 返回资源对应的流控规则集合
    private final Function<String, Collection<FlowRule>> ruleProvider = new Function<String, Collection<FlowRule>>() {
        @Override
        public Collection<FlowRule> apply(String resource) {
            Map<String, List<FlowRule>> flowRules = FlowRuleManager.getFlowRuleMap();   // ref: sign_demo_020
            return flowRules.get(resource);
        }
    };
}
  • com.alibaba.csp.sentinel.slots.block.flow.FlowRuleChecker
    // sign_m_720
    public void checkFlow(Function<String, Collection<FlowRule>> ruleProvider, ResourceWrapper resource,
                          Context context, DefaultNode node, int count, boolean prioritized) throws BlockException 
    {
        ... // 省略 ruleProvider 和 resource 为 null 返回
        Collection<FlowRule> rules = ruleProvider.apply(resource.getName());
        if (rules != null) {
            for (FlowRule rule : rules) {
                if (!canPassCheck(rule, context, node, count, prioritized)) {   // sign_m_721
                    throw new FlowException(rule.getLimitApp(), rule);
                }
            }
        }
    }

    // sign_m_721
    public boolean canPassCheck(FlowRule rule, Context context, DefaultNode node, int acquireCount,
                                                    boolean prioritized) 
    {
        ... // 省略 rule.limitApp 为 null 返回 true
        if (rule.isClusterMode()) {
            // ref: 集群流控-流控原理-sign_m_411
            return passClusterCheck(rule, context, node, acquireCount, prioritized);
        }
        return passLocalCheck(rule, context, node, acquireCount, prioritized);  // sign_m_722
    }

    // sign_m_722
    private static boolean passLocalCheck(FlowRule rule, Context context, DefaultNode node, int acquireCount,
                                          boolean prioritized) 
    {
        Node selectedNode = selectNodeByRequesterAndStrategy(rule, context, node);  // 查找统计节点
        if (selectedNode == null) {
            return true;
        }
        return rule.getRater().canPass(selectedNode, acquireCount, prioritized);    // 使用规则控制器进行判断，ref: sign_m_731
    }
  • com.alibaba.csp.sentinel.slots.block.flow.controller.DefaultController
    // sign_m_731 判断是否可以通过
    @Override
    public boolean canPass(Node node, int acquireCount, boolean prioritized) {
        int curCount = avgUsedTokens(node);     // sign_m_732
        if (curCount + acquireCount > count) {  // 判断是否超过自身设置的限制数
            if (prioritized && grade == RuleConstant.FLOW_GRADE_QPS) {
                long currentTime = TimeUtil.currentTimeMillis();
                long waitInMs = node.tryOccupyNext(currentTime, acquireCount, count);
                if (waitInMs < OccupyTimeoutProperty.getOccupyTimeout()) {
                    node.addWaitingRequest(currentTime + waitInMs, acquireCount);
                    node.addOccupiedPass(acquireCount);
                    sleep(waitInMs);
                    throw new PriorityWaitException(waitInMs);  // 报此异常可通过
                }
            }
            return false;   // 超过限制则返回 false (表示不通过)
        }
        return true;
    }

    // sign_m_732 返回当前计数
    private int avgUsedTokens(Node node) {
        if (node == null) {
            return DEFAULT_AVG_USED_TOKENS;
        }
        return grade == RuleConstant.FLOW_GRADE_THREAD ? node.curThreadNum() : (int)(node.passQps());
    }

DegradeSlot

  • 熔断处理

  • com.alibaba.csp.sentinel.slots.block.degrade.DegradeSlot

@Spi(order = Constants.ORDER_DEGRADE_SLOT)
public class DegradeSlot extends AbstractLinkedProcessorSlot<DefaultNode> {
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
                      boolean prioritized, Object... args) throws Throwable 
    {
        performChecking(context, resourceWrapper);                              // 先校验 sign_m_801
        fireEntry(context, resourceWrapper, node, count, prioritized, args);    // 再传给下游
    }

    // sign_m_801 熔断校验
    void performChecking(Context context, ResourceWrapper r) throws BlockException {
        List<CircuitBreaker> circuitBreakers = DegradeRuleManager.getCircuitBreakers(r.getName());
        if (circuitBreakers == null || circuitBreakers.isEmpty()) {
            return;
        }
        for (CircuitBreaker cb : circuitBreakers) {
            if (!cb.tryPass(context)) { // 熔断判断 sign_m_810
                // 不通过则进行熔断报错
                throw new DegradeException(cb.getRule().getLimitApp(), cb.getRule());
            }
        }
    }

    @Override // 退出时进行计数和状态处理
    public void exit(Context context, ResourceWrapper r, int count, Object... args) {
        Entry curEntry = context.getCurEntry();

        ... // 出现熔断 (有熔断异常) 则传给下游处理并返回

        List<CircuitBreaker> circuitBreakers = DegradeRuleManager.getCircuitBreakers(r.getName());

        ... // 无断路器则传给下游处理并返回

        if (curEntry.getBlockError() == null) {
            for (CircuitBreaker circuitBreaker : circuitBreakers) {
                circuitBreaker.onRequestComplete(context);  // 断路器计数与状态变更处理，ref: sign_m_830
            }
        }

        fireExit(context, r, count, args);
    }
}
  • com.alibaba.csp.sentinel.slots.block.degrade.circuitbreaker.AbstractCircuitBreaker
    // sign_m_810 熔断判断
    @Override
    public boolean tryPass(Context context) {
        if (currentState.get() == State.CLOSED) {
            return true;    // 断路器关闭：直接通过
        }
        if (currentState.get() == State.OPEN) {
            // 断路器已打开：超过指定熔断时间，尝试半打开处理
            return retryTimeoutArrived() && fromOpenToHalfOpen(context);    // sign_m_811 | sign_m_812
        }
        return false;       // 断路器半打开：不通过
    }

    // sign_m_811 判断是否超过熔断时长
    protected boolean retryTimeoutArrived() {
        return TimeUtil.currentTimeMillis() >= nextRetryTimestamp;
    }

    // sign_m_812 尝试半打开处理
    protected boolean fromOpenToHalfOpen(Context context) {
        if (currentState.compareAndSet(State.OPEN, State.HALF_OPEN)) {
            notifyObservers(State.OPEN, State.HALF_OPEN, null);
            Entry entry = context.getCurEntry();
            entry.whenTerminate(new BiConsumer<Context, Entry>() {  // 添加 entry.exit() 回调
                @Override
                public void accept(Context context, Entry entry) {  // 在 entry.exit() 被调用
                    if (entry.getBlockError() != null) {                            // 尝试请求时出错
                        currentState.compareAndSet(State.HALF_OPEN, State.OPEN);    // 重新打开
                        notifyObservers(State.HALF_OPEN, State.OPEN, 1.0d);
                    }
                }
            });
            return true;    // 只让一个线程 (且只进行一次) 处理
        }
        return false;       // 被其他线程抢占 (不通过)
    }
  • com.alibaba.csp.sentinel.slots.block.degrade.circuitbreaker.ExceptionCircuitBreaker
    // sign_m_830 断路器计数与状态变更处理
    @Override
    public void onRequestComplete(Context context) {
        Entry entry = context.getCurEntry();
        if (entry == null) {
            return;
        }
        Throwable error = entry.getError();
        SimpleErrorCounter counter = stat.currentWindow().value();
        if (error != null) {
            counter.getErrorCount().add(1); // 有异常，添加异常计数
        }
        counter.getTotalCount().add(1);     // 添加请求 (总) 计数

        handleStateChangeWhenThresholdExceeded(error);  // sign_m_831
    }

    // sign_m_831 状态变更处理
    private void handleStateChangeWhenThresholdExceeded(Throwable error) {
        ... // 当前状态为打开，则返回
        
        if (currentState.get() == State.HALF_OPEN) {// 当前为半打开状态
            if (error == null) {
                fromHalfOpenToClose();              // 无异常，则关闭
            } else {
                fromHalfOpenToOpen(1.0d);           // 有异常，则继续打开
            }
            return;
        }
        
        List<SimpleErrorCounter> counters = stat.values();
        long errCount = 0;
        long totalCount = 0;
        for (SimpleErrorCounter counter : counters) {
            errCount += counter.errorCount.sum();
            totalCount += counter.totalCount.sum();
        }
        if (totalCount < minRequestAmount) {
            return; // 小于最小请求数，不处理
        }
        double curCount = errCount;
        if (strategy == DEGRADE_GRADE_EXCEPTION_RATIO) {
            curCount = errCount * 1.0d / totalCount;    // 使用比率计算
        }
        if (curCount > threshold) {
            transformToOpen(curCount);                  // 超过阈值，开启熔断 (并设置开始重试的时间戳)
        }
    }

总结

  • 权限 (内置) 2 种规则 (但只支持设置 1 种，黑白名单互斥)
  • 流控 (内置) 有 4 (也可说 5) 种规则 (QPS 或线程数、速率、慢热 QPS、慢热速率)
  • 熔断 (内置) 有 2 (也可说 3) 种规则 (异常数或比率、响应时长)
Java-峰
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Ali sentinel 代码分析-基础及概念
weixin_40455124的博客
07-30 327
阿里Sentinel 基本概念主要包括： Chain及solt ，solt主要包括记录数据及执行规则两类 Chain可以自定义，有example Rule被solt调用执行，目前是4类rule Entry可以认为就是token，获得代表可以执行后续操作 Context 用于关联上下文，一般默认即可 ...
alibaba sentinel使用手册说明
08-27
alibaba sentinel 使用，个人学习笔记，共同进步。使用方便
springWebServlet添加ali-sentinel
qq_42212977的博客
08-25 174
gateway中添加统一的sentinel配置，单个服务如果需要也可以添加限流处理。 SentinelWebAutoConfiguration 自定义UrlCleaner实现 sentinel Rule中的资源组匹配, 如"/ss/aaa/bbb" -> "/ss/*" 自定义UrlBlockHandler实现自定义错误返回, response设置输出 自定义RequestOriginParser实现 request中用户信息或ip等提取， 通过AppName实现针对某特定用户群的限制
Alibaba Sentinel服务哨兵
qq_41128049的博客
05-23 765
Sentinel服务哨兵 Alibaba Sentinel 就是一款高性能且轻量级的流量控制、熔断降级可替换方案 Sentinel 官网：https://github.com/alibaba/Sentinel 1.Sentinel是什么 ​ 随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。 Sentinel 具有以下特征： 丰富的应用场景：Sentinel 承接了阿里巴巴近 10 年的双十一大促
Ali开源软件Sentinel的思考 Issue #59：关于线程限流问题的讨论
Tomcat的专栏
08-16 603
interface Limiter { boolean canPass(); void exit(); } class FlowLimiter implements Limiter { private AtomicInteger atomic; private int threadMax;//每一批线程的最大...
bitnami-docker-redis-sentinel：Bitnami Redis前哨Docker映像
02-16
Bitnami包装的Redis（TM）Sentinel是什么？ 免责声明：REDIS（r）是Redis Labs Ltd.的注册商标。RedisLabs Ltd.保留任何权利。Bitnami的任何使用仅供参考，并不表示Redis Labs Ltd之间有任何赞助，认可或从属关系。 ...
mall-user-sentinel-rule-push-demo.zip
05-12
《Sentinel规则推送示例——mall-user-sentinel-rule-push-demo》 Sentinel 是阿里巴巴开源的一款流量控制、熔断降级的 Java 库，它主要应用于微服务架构中的服务稳定性保障。在 mall-user-sentinel-rule-push-...
spring-cloud-alibaba-sentinel-gateway-2021.1-API文档-中文版.zip
05-09
赠送jar包：spring-cloud-alibaba-sentinel-gateway-2021.1.jar； 赠送原API文档：spring-cloud-alibaba-sentinel-gateway-2021.1-javadoc.jar； 赠送源代码：spring-cloud-alibaba-sentinel-gateway-2021.1-sources...
spring-cloud-starter-alibaba-sentinel-2021.1-API文档-中英对照版.zip
05-04
赠送jar包：spring-cloud-starter-alibaba-sentinel-2021.1.jar； 赠送原API文档：spring-cloud-starter-alibaba-sentinel-2021.1-javadoc.jar； 赠送源代码：spring-cloud-starter-alibaba-sentinel-2021.1-sources...
spring-cloud-starter-alibaba-sentinel-2021.1-API文档-中文版.zip
05-09
赠送jar包：spring-cloud-starter-alibaba-sentinel-2021.1.jar； 赠送原API文档：spring-cloud-starter-alibaba-sentinel-2021.1-javadoc.jar； 赠送源代码：spring-cloud-starter-alibaba-sentinel-2021.1-sources...
Sentinel原理
lgxzzz的博客
11-04 303
Sentinel原理 一、Sentinel 基本概念资源规则 二、Sentinel 功能和设计理念流量控制流量控制设计理念 三、 熔断降级什么是熔断降级熔断降级设计理念HystrixSentinel 对这个问题采取了两种手段通过并发线程数进行限制针对慢调用和异常对资源进行降级 系统自适应保护 四、Sentinel 是如何工作的五、Sentinel基于并发线程数流控 一、Sen...
​Sentinel限流规则-流控模式之链路模式​
kuyongganggang的专栏
03-22 2284
链路模式：只针对从指定链路访问到本资源的请求做统计，判断是否超过阈值。 例如有两条请求链路： /test1 /common /test2 /common 如果只希望统计从/test2进入到/common的请求，对/test2 进行限流，则可以这样配置： 案例：流控模式-链路 需求：有查询订单和创建订单业务，两者都需要查询商品。针对从查询订单进入到查询商品的请求统计，并设置限流。 步骤： 1.在OrderService中添加一个queryGoods方法，不用实现业务 2.
springcloud-alibaba-sentinel（4）sentinel流控详解
胖虎儿的博客
01-17 9921
使用sentinel进行流量监控与控制
5. Alibaba Sentinel 流控规则之链路
04-01 1356
1. 名词解释链路 介绍 链路是指调用路径， 假如某一个服务方法有多个调用来源， 如果我们只想限制来自于某一个来源的的调用路径， 就可以通过链路来限流，这个调用路径就是链路 比如在一个微服务中，两个接口都调用了同一个Service中的方法，并且该方法用SentinelResource（用于定义资源）注解标注了，然后对该注解标注的资源（方法）进行配置，则可以选择链路模式。 图解 2. 具体演示 1. 首先我们编写一个Service @Service public class TestS..
SpringCloud Alibaba微服务-- Sentinel的使用（保姆级）
热门推荐
知道的越多 不知道的就越多
07-04 1万+
sentinel的使用 sentinel保姆级教程 sentinel的下载及启动
Sentinel源码分析(三) - 调用链路
V_zxw的博客
02-07 1338
@Author：zxw @Email：502513206@qq.com 目录 Sentinel源码分析(一) - 初识Sentinel Sentinel源码分析(二) - Entry构建​ 1.前言 之前已经分析过Entry的构造流程，我们知道Sentinel关于规则和流控的所有逻辑都在其内部的ProcessorSlotChain调用链路上，首先看看接口提供的方法有哪些。对于链表结构我们清楚，就是不断获取下一个节点，然后进行方法调用。这里该接口提供了两个方法分别为入口entry和出口exit。对于出口
流量防护&链路追踪及分析-Sentinel+Sleuth(Zipkin)
微信公众号：饺子泡牛奶
07-16 1719
章节目录： 一、熔断降级限流 1.1 什么是熔断？ 1.2 什么是降级？ 1.3 什么是限流？ 1.4 熔断与降级区别 二、Sentinel 简介 2.1 基本概念 2.2 组成部分 2.3 四大特征 2.4 主要特性 2.5 相关文档 三、与同类组件 Hystrix 的区别 3.1 功能对比 3.2 熔断降级设计理念 3.3 熔断降级策略 3.4 系统自适应保护 四、Docker 下搭建 Sentinel 控制台 4.1 安装 4.2 登录控制台 五、SpringBoot 整合 Sentinel 5.1
Sentinel流控规则-链路
qq_41683000的博客
06-07 1150
Sentinel流控规则-链路
redis-sentinel安装
最新发布
08-27
要安装redis-sentinel，首先需要下载、解压、编译和安装redis。具体步骤如下： 1. 安装必要的linux库： ``` yum install gcc yum install tcl ``` 2. 创建redis用户和组： ``` groupadd redis useradd -g ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值