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.
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 penggunaanApabila perkhidmatan gagal atau dinaik taraf, biarkan pelanggan gagal dengan cepat
) Apabila beban lampau atau respons lambat berlaku, permintaan untuk beberapa antara muka dan data bukan teras akan ditinggalkan sementara secara dalaman dan
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 SentinelPada 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.
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!
Bagaimana untuk menentukan pembolehubah dalam golang
Apakah kaedah penukaran data dalam golang?
Apakah perpustakaan yang biasa digunakan di golang?
Apakah perbezaan antara golang dan ular sawa
Bagaimana untuk mengkonfigurasi pembolehubah persekitaran JDK
Bagaimana untuk menyelesaikan iis tidak boleh bermula
Perbezaan antara akaun perkhidmatan WeChat dan akaun rasmi
Bagaimana untuk menyelesaikan masalah yang nilai pulangan scanf diabaikan
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
