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

이 글은 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은 오픈 소스였으며 계속 발전하고 있습니다.

2019년 Sentinel은 다국어 확장 방향을 계속 탐색하여 C++ 기본 버전을 출시했으며, 서비스 하의 다국어 현재 제한 문제를 해결하기 위해 Service Mesh 시나리오에 대한 Envoy 클러스터 흐름 제어 지원도 출시했습니다. 메쉬 아키텍처.
2020년 Sentinel Go 버전이 출시되었으며 클라우드 네이티브 방향으로 계속 진화하고 있습니다.
2021년 Sentinel은 2.0 클라우드 기반 고가용성 의사 결정 센터 구성 요소로 발전하는 동시에 Sentinel Rust 기본 버전이 출시됩니다. 동시에 우리는 Rust 커뮤니티에서 Envoy WASM 확장 및 eBPF 확장과 같은 시나리오도 탐색했습니다.
2022년 Sentinel 브랜드는 트래픽 라우팅/스케줄링, 트래픽 색상 지정, 흐름 제어 저하, 과부하 보호/인스턴스 제거 등을 다루는 트래픽 관리로 업그레이드될 예정이며, 동시에 커뮤니티는 트래픽 관리를 추출할 것입니다. 관련 표준을 OpenSergo 표준으로 통합하고 Sentinel은 트래픽 관리 표준 구현 역할을 합니다.
• Sentinel-go 설치

Sentinel-go 오픈소스 주소 : https://github.com/alibaba/sentinel-golang

• 공식 웹사이트 문서

  설치: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 중국어 웹사이트의 기타 관련 기사를 참조하세요!