Apakah pengehadan dan peleburan semasa? Penjelasan terperinci tentang kemerosotan fius mengehadkan arus Sentinel

Artikel ini diperkenalkan kepada anda oleh ruangan tutorial golang tentang pengehadan arus Sentinel dan penurunan taraf pemutus litar Kandungannya termasuk pengenalan kepada pengehadan arus dan pemutus litar, serta pemasangan sumber terbuka alibaba , dan pengenalan praktikal Saya harap ia akan membantu rakan-rakan yang memerlukan.

Kemerosotan pemutus litar had arus sentinel

Apakah kemerosotan pemutus litar had semasa

Had semasa: Dalam sistem kami lusa, jika sejumlah besar trafik tiba-tiba memasuki hari itu, perkhidmatan kami hanya boleh mengendalikan 2k permintaan pada masa yang sama, tetapi tiba-tiba 5k permintaan masuk. Ini adalah masalah besar bagi Pelayan. Bukankah tekanannya sangat teruk? Ini boleh menyebabkan pelayan ditutup dan ranap, menyebabkan jumlah pemprosesan asal tidak dapat diproses Pada masa ini, kita perlu mengehadkan aliran mengehadkan adalah untuk mengekalkan akses Apabila trafik mencapai tahap tertinggi pada pelayan, adalah lebih baik untuk tidak memproses permintaan berlebihan

daripada terus menutup pelayan. Sebagai contoh, semasa Double Eleven, apabila kita ingin membuat pesanan, kita akan melihat sesuatu seperti "Permintaan itu

sibuk, sila cuba lagi nanti!".

Fius: Saya percaya semua orang sudah biasa dengan pemutus litar Ia bersamaan dengan suis, yang boleh menghalang aliran trafik apabila dibuka. Contohnya, fius akan bertiup apabila arus terlalu besar

untuk mengelakkan kerosakan pada komponen.

Pemutus litar servis bermaksud pemanggil mengakses perkhidmatan melalui pemutus litar sebagai proksi Pemutus litar akan terus memerhatikan status kejayaan dan kegagalan yang dikembalikan oleh perkhidmatan itu melebihi ambang yang ditetapkan Apabila pemutus litar dibuka, permintaan sebenarnya tidak boleh mengakses perkhidmatan.

Senario penggunaan

Apabila perkhidmatan gagal atau dinaik taraf, biarkan pelanggan gagal dengan cepat

Kegagalan Logik pemprosesan mudah ditakrifkan
Respons mengambil masa yang lama, dan tamat masa baca yang ditetapkan oleh pelanggan akan menjadi agak lama untuk menghalang pelanggan daripada mencuba semula sejumlah besar permintaan dan menyebabkan sambungan dan sumber benang tidak dapat dikeluarkan
* Turun taraf*: Turun taraf perkhidmatan adalah berdasarkan keadaan beban keseluruhan sistem menjadi agak tinggi, untuk mengelakkan fungsi tertentu (senario

• ) Apabila beban lampau atau respons lambat berlaku, permintaan untuk beberapa antara muka dan data bukan teras akan ditinggalkan sementara secara dalaman dan

disediakan maklumat pengendalian ralat sandar (fallback) dikembalikan terus. Dengan cara ini, walaupun ia menyediakan perkhidmatan yang rugi, ia memastikan kestabilan dan ketersediaan keseluruhan sistem.

Apa itu Sentinel

Sentinel ialah projek sumber terbuka Alibaba Ia menyediakan kawalan aliran, degradasi pemutus litar, perlindungan beban sistem dan dimensi lain untuk memastikan kestabilan perkhidmatan seks.

Tapak web rasmi: github.com/alibaba/Sentinel/wiki

Sentinel dilahirkan di Alibaba pada 2012, dan matlamat utamanya ialah kawalan trafik. Dari 2013 hingga 2017, Sentinel berkembang pesat dan menjadi komponen asas semua perkhidmatan mikro Alibaba. Ia digunakan dalam lebih daripada 6000 aplikasi, meliputi hampir semua senario teras e-dagang. Pada 2018, Sentinel berkembang menjadi projek sumber terbuka. Pada tahun 2020, Sentinel Golang telah dikeluarkan. Ciri:

Senario aplikasi yang kaya: Sentinel telah melaksanakan senario teras trafik promosi Double Eleven Alibaba dalam tempoh 10 tahun yang lalu, seperti jualan kilat (iaitu

Trafik pecah kawalan dalam julat yang boleh ditanggung oleh kapasiti sistem), pencukuran puncak mesej dan pengisian lembah, kawalan trafik kelompok, penggabungan masa nyata aplikasi hiliran yang tidak tersedia, dsb.

Pemantauan masa nyata lengkap: Sentinel juga menyediakan fungsi pemantauan masa nyata. Dalam konsol, anda boleh melihat data peringkat kedua bagi satu mesin

yang disambungkan kepada aplikasi, malah status operasi ringkasan gugusan dengan kurang daripada 500 mesin.

* Ekologi Luas*

Sejarah Sentinel

Pada 2012, Sentinel dilahirkan, dengan fungsi utama salur masuk kawalan aliran.

Dari 2013 hingga 2017, Sentinel berkembang pesat dalam Kumpulan Alibaba dan menjadi modul teknologi asas, meliputi semua senario teras. Akibatnya, Sentinel telah mengumpulkan sejumlah besar senario penyatuan trafik dan amalan pengeluaran.

• Pada 2018, Sentinel adalah sumber terbuka dan terus berkembang.

• Pada tahun 2019, Sentinel terus meneroka arah pengembangan berbilang bahasa dan melancarkan versi asli C Pada masa yang sama, ia juga melancarkan sokongan kawalan aliran kelompok Envoy untuk senario Service Mesh untuk menyelesaikan masalah seni bina Service Mesh Menyelesaikan masalah had semasa berbilang bahasa.

• Pada tahun 2020, versi Sentinel Go telah dilancarkan dan terus berkembang ke arah asal awan.

• Pada tahun 2021, Sentinel sedang berkembang ke arah komponen pusat keputusan ketersediaan tinggi asli awan 2.0 pada masa yang sama, versi asli Sentinel Rust dilancarkan. Pada masa yang sama, kami juga meneroka senario seperti sambungan Envoy WASM dan sambungan eBPF dalam komuniti Rust.

• Pada tahun 2022, jenama Sentinel akan dinaik taraf kepada pengurusan trafik, meliputi penghalaan/penjadualan trafik, pewarnaan trafik, kemerosotan kawalan aliran, perlindungan lebihan/penyingkiran instance, dsb.; masa, komuniti akan membangunkan piawaian yang berkaitan dengan pengurusan trafik Diekstrak ke dalam standard OpenSergo, Sentinel dilaksanakan sebagai piawaian pengurusan trafik.

• Pemasangan Sentinel-go

• Alamat sumber terbuka Sentinel-go: https://github.com/alibaba/sentinel-golang

  Dokumentasi laman web rasmi

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

  Go current limiting practice

  qps current limiting

  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()
          }
      }
  }

  Hasil cetakan:

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

  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
  }

  Hasil cetakan: Mencapai 1k secara beransur-ansur, pada 1k Kedudukan turun naik ke atas dan ke bawah

  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

  Pergi pemutus litar sebenar

  Di sini kami memperkenalkan nombor yang salah, lihat mekanisme pemutus litar terperinci

  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
  }

Atas ialah kandungan terperinci Apakah pengehadan dan peleburan semasa? Penjelasan terperinci tentang kemerosotan fius mengehadkan arus Sentinel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!