집 > 기사 > 백엔드 개발 > 전류 제한 및 퓨즈란 무엇입니까? Sentinel 전류 제한 퓨즈 성능 저하에 대한 자세한 설명

전류 제한 및 퓨즈란 무엇입니까? Sentinel 전류 제한 퓨즈 성능 저하에 대한 자세한 설명

藏色散人앞으로: 2022-11-13 16:37:402771검색

이 글은 Sentinel 전류 제한 및 회로 차단기 다운그레이드에 대한 golang 튜토리얼 칼럼에서 소개한 내용입니다. 내용에는 전류 제한 및 회로 차단기에 대한 소개와 함께 alibaba 오픈 소스 Sentinel, 설치 및 실제 소개가 포함되어 있습니다. 도움이 필요한 친구들에게 도움이 되길 바랍니다!

Sentinel 전류 제한 회로 차단기 다운그레이드

전류 제한 회로 차단기 다운그레이드란 무엇인가요?

전류 제한: 당사가 확보한 시스템에서는 그날 갑자기 대량의 트래픽이 유입되는 경우에만 서비스를 제공할 수 있습니다. 최대 2K 요청을 동시에 처리했는데 갑자기 5K 요청이 들어왔습니다. 이는 서버에 엄청난 부담이 되지 않습니까? 이로 인해 직접적으로 서버가 다운되고 충돌이 발생하여 원래 2K의 처리 용량을 사용할 수 없게 될 수도 있습니다. 이때 흐름 제한의 기능은 서버 방문 횟수를 최고 수준으로 유지하고 중복된 요청을 처리하지 않는 것입니다. 서버를 끊습니다. 예를 들어 더블 일레븐(Double Eleven) 기간 동안 주문을 하려고 하면 "요청이 처리 중입니다. 나중에 다시 시도해 주세요!"와 같은 메시지가 표시됩니다.

Fuse: 회로 차단기는 열렸을 때 차량의 흐름을 막을 수 있는 스위치와 동일합니다. 예를 들어, 전류가 너무 크면 퓨즈가 끊어져 부품 손상을 방지할 수 있습니다.

서비스 회로 차단기는 호출자가 회로 차단기를 통해 서비스에 프록시로 액세스하는 것을 의미합니다.

실패가 설정된 임계값을 초과하면 회로 차단기가 계속해서 관찰됩니다. 열려 있고 요청을 인증할 수 없습니다. 서비스가 로컬로 액세스됩니다.

사용 시나리오

서비스가 실패하거나 업그레이드되면 클라이언트가 빠르게 실패하도록 하세요

실패 처리 로직을 쉽게 정의할 수 있습니다

시나리오)이 과부하되거나 느리게 응답하는 경우 일부 비핵심 인터페이스 및 데이터에 대한 요청이 내부적으로 일시적으로 중단되고
Sentinel이란

Sentinel은 Alibaba의 오픈 소스 프로젝트로, 흐름 제어, 회로 차단기 성능 저하, 시스템 부하 보호 등 다양한 차원을 제공하여 서비스 안정성을 보장합니다.

공식 웹사이트: github.com/alibaba/Sentinel/wiki

Sentinel은 2012년 Alibaba에서 탄생했으며 주요 목표는 교통 통제입니다. 2013년부터 2017년까지 Sentinel은 빠르게 발전하여 모든 Alibaba 마이크로서비스의 기본 구성 요소가 되었습니다. 거의 모든 핵심 전자 상거래 시나리오를 포괄하는 6000개 이상의 애플리케이션에서 사용됩니다. 2018년 Sentinel은 오픈소스 프로젝트로 발전했습니다. 2020년에는 Sentinel Golang이 출시되었습니다.

특징:

풍부한 애플리케이션 시나리오: Sentinel은 지난 10년 동안 반짝 세일과 같은 Alibaba의 Double Eleven 트래픽 프로모션의 핵심 시나리오를 수행했습니다(즉, 버스트 트래픽은 시스템 용량이 감당할 수 있는 범위 내에서 제어됩니다). , 메시징 피크 감소 및 밸리 채우기, 클러스터 흐름 제어, 다운스트림에서 사용할 수 없는 애플리케이션의 실시간 융합 등

완전한 실시간 모니터링: Sentinel은 실시간 모니터링 기능도 제공합니다. 애플리케이션에 연결된 단일 머신의 2차 데이터를 콘솔에서 볼 수 있으며, 500대 미만 머신으로 구성된 클러스터의 요약 작업 상태까지 볼 수 있습니다.

* 광범위한 생태학 *

Sentinel의 역사

2012년 Sentinel이 탄생했으며 주요 기능은 흡입 유량 제어입니다.

2013년부터 2017년까지 Sentinel은 Alibaba Group 내에서 빠르게 발전하여 모든 핵심 시나리오를 포괄하는 기본 기술 모듈이 되었습니다. 따라서 Sentinel은 수많은 트래픽 통합 시나리오와 생산 사례를 축적했습니다.

2018년 Sentinel은 오픈 소스였으며 계속 발전하고 있습니다.

Sentinel-go 설치

공식 웹사이트 문서

설치:go get github.com/alibaba/sentinel-golang/api

현재 제한 연습하기

qps 현재 제한

package main

import (
    "fmt"
    "log"

    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/base"
    "github.com/alibaba/sentinel-golang/core/flow"
)

func main() {
    //基于sentinel的qps限流
    //必须初始化
    err := sentinel.InitDefault()
    if err != nil {
        log.Fatalf("Unexpected error: %+v", err)
    }

    //配置限流规则：1秒内通过10次
    _, err = flow.LoadRules([]*flow.Rule{
        {
            Resource:               "some_test",
            TokenCalculateStrategy: flow.Direct,
            ControlBehavior:        flow.Reject, //超过直接拒绝
            Threshold:              10,          //请求次数
            StatIntervalInMs:       1000,        //允许时间内
        },
    })

    if err != nil {
        log.Fatalf("Unexpected error: %+v", err)
        return
    }

    for i := 0; i < 12; i++ {
        e, b := sentinel.Entry("some_test", sentinel.WithTrafficType(base.Inbound))
        if b != nil {
            fmt.Println("限流了")
        } else {
            fmt.Println("检查通过")
            e.Exit()
        }
    }
}

인쇄 결과:

检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
限流了
限流了

Thrnotting

package main

import (
    "fmt"
    "log"
    "time"

    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/base"
    "github.com/alibaba/sentinel-golang/core/flow"
)

func main() {
    //基于sentinel的qps限流
    //必须初始化
    err := sentinel.InitDefault()
    if err != nil {
        log.Fatalf("Unexpected error: %+v", err)
    }

    //配置限流规则
    _, err = flow.LoadRules([]*flow.Rule{
        {
            Resource:               "some_test",
            TokenCalculateStrategy: flow.Direct,
            ControlBehavior:        flow.Throttling, //匀速通过
            Threshold:              10,              //请求次数
            StatIntervalInMs:       1000,            //允许时间内
        },
    })

    if err != nil {
        log.Fatalf("Unexpected error: %+v", err)
        return
    }

    for i := 0; i < 12; i++ {
        e, b := sentinel.Entry("some_test", sentinel.WithTrafficType(base.Inbound))
        if b != nil {
            fmt.Println("限流了")
        } else {
            fmt.Println("检查通过")
            e.Exit()
        }
        time.Sleep(time.Millisecond * 100)
    }
}

检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
检查通过
检查通过

Warrm_up

package main

import (
    "fmt"
    "log"
    "math/rand"
    "time"

    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/base"
    "github.com/alibaba/sentinel-golang/core/flow"
)

func main() {
    //先初始化sentinel
    err := sentinel.InitDefault()
    if err != nil {
        log.Fatalf("初始化sentinel 异常: %v", err)
    }

    var globalTotal int
    var passTotal int
    var blockTotal int
    ch := make(chan struct{})

    //配置限流规则
    _, err = flow.LoadRules([]*flow.Rule{
        {
            Resource:               "some-test",
            TokenCalculateStrategy: flow.WarmUp, //冷启动策略
            ControlBehavior:        flow.Reject, //直接拒绝
            Threshold:              1000,
            WarmUpPeriodSec:        30,
        },
    })

    if err != nil {
        log.Fatalf("加载规则失败: %v", err)
    }

    //我会在每一秒统计一次，这一秒只能 你通过了多少，总共有多少， block了多少, 每一秒会产生很多的block
    for i := 0; i < 100; i++ {
        go func() {
            for {
                globalTotal++
                e, b := sentinel.Entry("some-test", sentinel.WithTrafficType(base.Inbound))
                if b != nil {
                    //fmt.Println("限流了")
                    blockTotal++
                    time.Sleep(time.Duration(rand.Uint64()%10) * time.Millisecond)
                } else {
                    passTotal++
                    time.Sleep(time.Duration(rand.Uint64()%10) * time.Millisecond)
                    e.Exit()
                }
            }
        }()
    }

    go func() {
        var oldTotal int //过去1s总共有多少个
        var oldPass int  //过去1s总共pass多少个
        var oldBlock int //过去1s总共block多少个
        for {
            oneSecondTotal := globalTotal - oldTotal
            oldTotal = globalTotal

            oneSecondPass := passTotal - oldPass
            oldPass = passTotal

            oneSecondBlock := blockTotal - oldBlock
            oldBlock = blockTotal

            time.Sleep(time.Second)
            fmt.Printf("total:%d, pass:%d, block:%d\n", oneSecondTotal, oneSecondPass, oneSecondBlock)
        }
    }()

    <-ch
}

인쇄 결과: 점차적으로 1k에 도달합니다. 1k 위치 위아래로 변동

total:11, pass:9, block:0
total:21966, pass:488, block:21420
total:21793, pass:339, block:21414
total:21699, pass:390, block:21255
total:21104, pass:393, block:20654
total:21363, pass:453, block:20831
total:21619, pass:491, block:21052
total:21986, pass:533, block:21415
total:21789, pass:594, block:21123
total:21561, pass:685, block:20820
total:21663, pass:873, block:20717
total:20904, pass:988, block:19831
total:21500, pass:996, block:20423
total:21769, pass:1014, block:20682
total:20893, pass:1019, block:19837
total:21561, pass:973, block:20524
total:21601, pass:1014, block:20517
total:21475, pass:993, block:20420
total:21457, pass:983, block:20418
total:21397, pass:1024, block:20320
total:21690, pass:996, block:20641
total:21526, pass:991, block:20457
total:21779, pass:1036, block:20677

실제 차단기 전투 보러가기

여기서 잘못된 숫자를 소개합니다. 자세한 차단기 메커니즘을 확인하세요

error_count
package main

import (
    "errors"
    "fmt"
    "log"
    "math/rand"
    "time"

    sentinel "github.com/alibaba/sentinel-golang/api"
    "github.com/alibaba/sentinel-golang/core/circuitbreaker"
    "github.com/alibaba/sentinel-golang/core/config"
    "github.com/alibaba/sentinel-golang/logging"
    "github.com/alibaba/sentinel-golang/util"
)

type stateChangeTestListener struct {
}

func (s *stateChangeTestListener) OnTransformToClosed(prev circuitbreaker.State, rule circuitbreaker.Rule) {
    fmt.Printf("rule.steategy: %+v, From %s to Closed, time: %d\n", rule.Strategy, prev.String(), util.CurrentTimeMillis())
}

func (s *stateChangeTestListener) OnTransformToOpen(prev circuitbreaker.State, rule circuitbreaker.Rule, snapshot interface{}) {
    fmt.Printf("rule.steategy: %+v, From %s to Open, snapshot: %d, time: %d\n", rule.Strategy, prev.String(), snapshot, util.CurrentTimeMillis())
}

func (s *stateChangeTestListener) OnTransformToHalfOpen(prev circuitbreaker.State, rule circuitbreaker.Rule) {
    fmt.Printf("rule.steategy: %+v, From %s to Half-Open, time: %d\n", rule.Strategy, prev.String(), util.CurrentTimeMillis())
}

func main() {
    //基于连接数的降级模式
    total := 0
    totalPass := 0
    totalBlock := 0
    totalErr := 0
    conf := config.NewDefaultConfig()
    // for testing, logging output to console
    conf.Sentinel.Log.Logger = logging.NewConsoleLogger()
    err := sentinel.InitWithConfig(conf)
    if err != nil {
        log.Fatal(err)
    }
    ch := make(chan struct{})
    // Register a state change listener so that we could observer the state change of the internal circuit breaker.
    circuitbreaker.RegisterStateChangeListeners(&stateChangeTestListener{})

    _, err = circuitbreaker.LoadRules([]*circuitbreaker.Rule{
        // Statistic time span=10s, recoveryTimeout=3s, maxErrorCount=50
        {
            Resource:         "abc",
            Strategy:         circuitbreaker.ErrorCount,
            RetryTimeoutMs:   3000, //3s只有尝试回复
            MinRequestAmount: 10,   //静默数
            StatIntervalMs:   5000,
            Threshold:        50,
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    logging.Info("[CircuitBreaker ErrorCount] Sentinel Go circuit breaking demo is running. You may see the pass/block metric in the metric log.")
    go func() {
        for {
            total++
            e, b := sentinel.Entry("abc")
            if b != nil {
                // g1 blocked
                totalBlock++
                fmt.Println("协程熔断了")
                time.Sleep(time.Duration(rand.Uint64()%20) * time.Millisecond)
            } else {
                totalPass++
                if rand.Uint64()%20 > 9 {
                    totalErr++
                    // Record current invocation as error.
                    sentinel.TraceError(e, errors.New("biz error"))
                }
                // g1 passed
                time.Sleep(time.Duration(rand.Uint64()%20+10) * time.Millisecond)
                e.Exit()
            }
        }
    }()
    go func() {
        for {
            total++
            e, b := sentinel.Entry("abc")
            if b != nil {
                // g2 blocked
                totalBlock++
                time.Sleep(time.Duration(rand.Uint64()%20) * time.Millisecond)
            } else {
                // g2 passed
                totalPass++
                time.Sleep(time.Duration(rand.Uint64()%80) * time.Millisecond)
                e.Exit()
            }
        }
    }()

    go func() {
        for {
            time.Sleep(time.Second)
            fmt.Println(totalErr)
        }
    }()
    <-ch
}

위 내용은 전류 제한 및 퓨즈란 무엇입니까? Sentinel 전류 제한 퓨즈 성능 저하에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

golang rust 架构 sentinel 接口线程 github https wasm

성명：

이 기사는 learnku.com에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제