SRE: စွမ်းဆောင်ရည် ပိုင်းခြားစိတ်ဖြာခြင်း။ Go တွင် ရိုးရှင်းသော ဝဘ်ဆာဗာကို အသုံးပြု၍ ဖွဲ့စည်းမှုနည်းလမ်း

စွမ်းဆောင်ရည်ပိုင်းခြားစိတ်ဖြာခြင်းနှင့် ချိန်ညှိခြင်းသည် ဖောက်သည်များအတွက် စွမ်းဆောင်ရည်လိုက်လျောညီထွေဖြစ်ကြောင်း အတည်ပြုရန် အစွမ်းထက်သောကိရိယာတစ်ခုဖြစ်သည်။

သိပ္ပံနည်းကျ ချဉ်းကပ်စမ်းသပ်ခြင်း စမ်းသပ်မှုများကို အသုံးချခြင်းဖြင့် ပရိုဂရမ်တစ်ခုရှိ ပိတ်ဆို့မှုများကို စစ်ဆေးရန်အတွက် စွမ်းဆောင်ရည်ပိုင်းခွဲခြမ်းစိတ်ဖြာမှုကို အသုံးပြုနိုင်သည်။ Go webserver ကို နမူနာအဖြစ် အသုံးပြု၍ စွမ်းဆောင်ရည်ခွဲခြမ်းစိတ်ဖြာခြင်းနှင့် ချိန်ညှိခြင်းဆိုင်ရာ ယေဘုယျချဉ်းကပ်နည်းကို ဤဆောင်းပါးတွင် ဖော်ပြထားပါသည်။

သူ့တွင် ပရိုဖိုင်ရေးကိရိယာများ ပါရှိသောကြောင့် Go သည် အထူးကောင်းမွန်ပါသည်။ pprof စံစာကြည့်တိုက်တွင်။

နည်းဗျူဟာ

ကျွန်ုပ်တို့၏ဖွဲ့စည်းပုံဆိုင်ရာခွဲခြမ်းစိတ်ဖြာမှုအတွက် အကျဉ်းချုပ်စာရင်းတစ်ခု ဖန်တီးကြပါစို့။ ထိုးထွင်းသိမြင်မှု သို့မဟုတ် မှန်းဆမှုအပေါ်အခြေခံ၍ ပြောင်းလဲမှုများပြုလုပ်မည့်အစား ဆုံးဖြတ်ချက်များချရန် ဒေတာအချို့ကို အသုံးပြုရန် ကြိုးစားပါမည်။ ဒါကိုလုပ်ဖို့၊

• ကျွန်ုပ်တို့သည် ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ရန် နယ်နိမိတ်များ (လိုအပ်ချက်များ) ကို ဆုံးဖြတ်ပါသည်။
• ကျွန်ုပ်တို့သည် စနစ်အတွက် ငွေပေးငွေယူဝန်ကို တွက်ချက်ပါသည်။
• ကျွန်ုပ်တို့သည် စမ်းသပ်မှုပြုလုပ်ခြင်း (ဒေတာဖန်တီးခြင်း)၊
• ငါတို့စောင့်ကြည့်;
• ကျွန်ုပ်တို့ ခွဲခြမ်းစိတ်ဖြာပါ - လိုအပ်ချက်များအားလုံး ပြည့်မီပါသလား။
• အဲဒါကို သိပ္ပံနည်းကျ သတ်မှတ်ပြီး အယူအဆတစ်ခု ဖန်တီးပါ။
• ဤယူဆချက်ကို စမ်းသပ်ရန် ကျွန်ုပ်တို့သည် စမ်းသပ်မှုတစ်ခု ပြုလုပ်ပါသည်။

ရိုးရှင်းသော HTTP ဆာဗာဗိသုကာ

ဤဆောင်းပါးအတွက် ကျွန်ုပ်တို့သည် Golang ရှိ HTTP ဆာဗာငယ်ကို အသုံးပြုပါမည်။ ဤဆောင်းပါးမှကုဒ်အားလုံးကို တွေ့နိုင်သည်။ ဒီမှာ.

ခွဲခြမ်းစိတ်ဖြာထားသည့် အပလီကေးရှင်းသည် တောင်းဆိုချက်တစ်ခုစီအတွက် Postgresql ကို စစ်တမ်းကောက်ယူသည့် HTTP ဆာဗာတစ်ခုဖြစ်သည်။ ထို့အပြင်၊ အပလီကေးရှင်းနှင့်စနစ်မက်ထရစ်များကိုစုဆောင်းခြင်းနှင့်ပြသရန်အတွက် Prometheus၊ node_exporter နှင့် Grafana ရှိသည်။

ရိုးရှင်းစေရန်၊ အလျားလိုက် အတိုင်းအတာ (နှင့် တွက်ချက်မှုများကို ရိုးရှင်းအောင်ပြုလုပ်ရန်) ဝန်ဆောင်မှုနှင့် ဒေတာဘေ့စ်တစ်ခုစီကို အတူတကွ အသုံးပြုနိုင်သည်ဟု ကျွန်ုပ်တို့ ယူဆပါသည်-

ပန်းတိုင်များသတ်မှတ်ခြင်း။

ဤအဆင့်တွင် ကျွန်ုပ်တို့သည် ပန်းတိုင်ကို ဆုံးဖြတ်သည်။ ဘာကိုခွဲခြမ်းစိတ်ဖြာဖို့ကြိုးစားနေတာလဲ။ ကုန်ဆုံးချိန်ရောက်သောအခါ ကျွန်ုပ်တို့ မည်သို့သိနိုင်မည်နည်း။ ဤဆောင်းပါးတွင်၊ ကျွန်ုပ်တို့တွင် ဖောက်သည်များရှိကြောင်းနှင့် ကျွန်ုပ်တို့၏ဝန်ဆောင်မှုသည် တစ်စက္ကန့်လျှင် တောင်းဆိုချက် ၁၀,၀၀၀ ကို လုပ်ဆောင်ပေးမည်ဟု စိတ်ကူးကြည့်ပါမည်။

В Google SRE စာအုပ် ရွေးချယ်ပုံနှင့် မော်ဒယ်လုပ်နည်းများကို အသေးစိတ် ဆွေးနွေးထားသည်။ တူညီသောပုံစံများကိုတည်ဆောက်ကြပါစို့။

• Latency- တောင်းဆိုမှု 99% သည် 60ms ထက်နည်း၍ ပြီးသင့်သည်၊
• ကုန်ကျစရိတ်- ဝန်ဆောင်မှုသည် ကျိုးကြောင်းဆီလျော်စွာ ဖြစ်နိုင်သည်ဟု ကျွန်ုပ်တို့ထင်သည့် အနည်းဆုံး ငွေပမာဏကို သုံးစွဲသင့်သည်။ ဒီလိုလုပ်ဖို့၊ ကျွန်ုပ်တို့သည် လမ်းကြောင်းကို ချဲ့ထွင်သည်။
• စွမ်းဆောင်ရည် အစီအစဉ်ဆွဲခြင်း- အပလီကေးရှင်း၏ အတိုင်းအတာမည်မျှ လုပ်ဆောင်ရန် လိုအပ်မည်ကို နားလည်ပြီး မှတ်တမ်းတင်ရန် လိုအပ်သည်၊ အလုံးစုံ အတိုင်းအတာ လုပ်ဆောင်ချက် အပါအဝင်၊ နှင့် ကနဦး ဝန်ထုပ်ဝန်ပိုးနှင့် စီမံဆောင်ရွက်ပေးမှု လိုအပ်ချက်များ ပြည့်မီရန် ဖြစ်ရပ်မည်မျှ လိုအပ်မည် အထပ်ထပ် n+1.

Latency ကို ခွဲခြမ်းစိတ်ဖြာခြင်းအပြင် ပိုမိုကောင်းမွန်အောင်ပြုလုပ်ရန် လိုအပ်နိုင်သော်လည်း ထုတ်လွှင့်မှုအား ရှင်းရှင်းလင်းလင်း ခွဲခြမ်းစိတ်ဖြာရန် လိုအပ်ပါသည်။ SRE SLO လုပ်ငန်းစဉ်ကို အသုံးပြုသည့်အခါ နှောင့်နှေးမှုတောင်းဆိုချက်သည် ကုန်ပစ္စည်းပိုင်ရှင်မှ ကိုယ်စားပြုသည့် ဖောက်သည် သို့မဟုတ် လုပ်ငန်းထံမှ လာပါသည်။ ကျွန်ုပ်တို့၏ဝန်ဆောင်မှုသည် မည်သည့်ဆက်တင်များမပါဘဲ အစကတည်းက ဤတာဝန်ကို ဖြည့်ဆည်းပေးမည်ဖြစ်သည်။

စမ်းသပ်မှုပတ်ဝန်းကျင်ကို သတ်မှတ်ခြင်း။

စမ်းသပ်မှုပတ်ဝန်းကျင်၏အကူအညီဖြင့်၊ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏စနစ်တွင် တိုင်းတာသည့်ဝန်ကို ထားရှိနိုင်မည်ဖြစ်သည်။ ခွဲခြမ်းစိတ်ဖြာရန်အတွက်၊ ဝဘ်ဝန်ဆောင်မှု၏ စွမ်းဆောင်ရည်ဆိုင်ရာ အချက်အလက်များကို ထုတ်ပေးမည်ဖြစ်သည်။

ငွေလွှဲပေးပါသည်။

ဒီပတ်ဝန်းကျင်က သုံးတယ်။ Vegeta ရပ်တန့်သည်အထိ စိတ်ကြိုက် HTTP တောင်းဆိုမှုနှုန်းကို ဖန်တီးရန်-

$ make load-test LOAD_TEST_RATE=50
echo "POST http://localhost:8080" | vegeta attack -body tests/fixtures/age_no_match.json -rate=50 -duration=0 | tee results.bin | vegeta report

စောင့်ကြည့်

Runtime တွင် အရောင်းအ၀ယ်ဝန်ကို အသုံးချပါမည်။ အပလီကေးရှင်း (တောင်းဆိုမှုအရေအတွက်၊ တုံ့ပြန်မှုကြာချိန်) နှင့် လည်ပတ်မှုစနစ် (မမ်မိုရီ၊ CPU၊ IOPS) မက်ထရစ်များအပြင်၊ ၎င်းတွင် ပြဿနာများနှင့် CPU အချိန်ကို မည်ကဲ့သို့သုံးစွဲနေသည်ကို နားလည်ရန် အပလီကေးရှင်းပရိုဖိုင်ကို လုပ်ဆောင်ပေးမည်ဖြစ်သည်။

စာရင်းသွင်းခြင်း။

ပရိုဖိုင်းသည် အက်ပလီကေးရှင်းတစ်ခုလည်ပတ်နေချိန်တွင် CPU အချိန်သွားနေသည့်နေရာကို မြင်နိုင်စေမည့် တိုင်းတာမှုအမျိုးအစားတစ်ခုဖြစ်သည်။ ၎င်းသည် သင့်အား မည်သည့်နေရာနှင့် ပရိုဆက်ဆာအချိန်မည်မျှ သုံးစွဲသည်ကို အတိအကျ ဆုံးဖြတ်နိုင်စေသည်-

ဖြုန်းတီးနေသော CPU အချိန်နှင့် မလိုအပ်သော အလုပ်များကို လုပ်ဆောင်နေခြင်းကို ထိုးထွင်းသိမြင်နိုင်စေရန်အတွက် ဤဒေတာကို ခွဲခြမ်းစိတ်ဖြာရာတွင် အသုံးပြုနိုင်သည်။ Go (pprof) သည် ပရိုဖိုင်များကို ဖန်တီးနိုင်ပြီး ၎င်းတို့ကို စံကိရိယာအစုံအလင်ကို အသုံးပြု၍ မီးတောက်ဂရပ်ဖစ်များအဖြစ် မြင်ယောင်နိုင်သည်။ ဆောင်းပါးတွင် ၎င်းတို့၏ အသုံးပြုမှုနှင့် တပ်ဆင်မှုလမ်းညွှန်အကြောင်း နောက်ပိုင်းတွင် ပြောပြပါမည်။

စီရင်ခြင်း၊ လေ့လာခြင်း၊ ခွဲခြမ်းစိတ်ဖြာခြင်း။

စမ်းသပ်မှုတစ်ခုလုပ်ကြည့်ရအောင်။ ကျွန်ုပ်တို့သည် စွမ်းဆောင်ရည်ကို ကျေနပ်သည်အထိ လုပ်ဆောင်ပါ၊ စောင့်ကြည့်လေ့လာပြီး ခွဲခြမ်းစိတ်ဖြာပါမည်။ ပထမအကြိမ်လေ့လာတွေ့ရှိချက်များရရှိရန် ၎င်းကိုအသုံးပြုရန် နိုင်ထက်စီးနင်းနိမ့်သောတန်ဖိုးကို ရွေးချယ်ကြပါစို့။ နောက်အဆင့်တစ်ခုစီတွင် ကျွန်ုပ်တို့သည် ကွဲပြားမှုအချို့ဖြင့် ရွေးချယ်ထားသော အတိုင်းအတာတစ်ခုအထိ အတိုင်းအတာတစ်ခုဖြင့် ဝန်ကို တိုးပေးမည်ဖြစ်သည်။ တောင်းဆိုမှုအရေအတွက်ကို ချိန်ညှိထားသော ဝန်စမ်းသပ်မှုတစ်ခုစီကို လုပ်ဆောင်သည်- make load-test LOAD_TEST_RATE=X.

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် ၅၀

ထိပ်တန်းဂရပ်နှစ်ခုကို အာရုံစိုက်ပါ။ ကျွန်ုပ်တို့၏ လျှောက်လွှာသည် တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 50 ကို လုပ်ဆောင်ကြောင်း ဘယ်ဘက်အပေါ်မှ ပြသပြီး ညာဘက်အပေါ်ထောင့်သည် တောင်းဆိုချက်တစ်ခုစီ၏ ကြာချိန်ကို ပြသသည်။ ကန့်သတ်ချက်များ နှစ်ခုစလုံးသည် ကျွန်ုပ်တို့၏ စွမ်းဆောင်ရည် နယ်နိမိတ်များအတွင်းတွင် ရှိနေသည်ဖြစ်စေ မရှိသည်ကို ကြည့်ရှု ခွဲခြမ်းစိတ်ဖြာရန် ကူညီပေးပါသည်။ ဂရပ်ပေါ်တွင် အနီရောင်မျဉ်း HTTP Request Latency 60ms တွင် SLO ကိုပြသသည်။ လိုင်းက ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ တုံ့ပြန်မှုအများဆုံးအချိန်အောက်တွင် ကောင်းမွန်ကြောင်း ပြသသည်။

ကုန်ကျစရိတ်ကို ကြည့်ရအောင်။

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 10000 / ဆာဗာတစ်ခုလျှင် တောင်းဆိုချက် 50 ခု = ဆာဗာ 200 + 1

ဒီကိန်းဂဏန်းကို မြှင့်တင်နိုင်ပါသေးတယ်။

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် ၅၀

load သည် တစ်စက္ကန့်လျှင် တောင်းဆိုမှု 500 သို့ရောက်ရှိသောအခါတွင် ပိုမိုစိတ်ဝင်စားစရာကောင်းသောအရာများ စတင်ဖြစ်ပေါ်လာသည်-

တဖန်၊ ဘယ်ဘက်အပေါ်ဆုံးဂရပ်တွင် အပလီကေးရှင်းသည် ပုံမှန်ဝန်အားကို မှတ်တမ်းတင်ထားသည်ကို တွေ့နိုင်သည်။ ထိုသို့မဟုတ်ပါက၊ အပလီကေးရှင်းကိုလည်ပတ်နေသည့်ဆာဗာတွင် ပြဿနာရှိနေပါသည်။ တုံ့ပြန်မှု latency ဂရပ်သည် ညာဘက်အပေါ်တွင် တည်ရှိပြီး တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 500 သည် တုံ့ပြန်မှုနှောင့်နှေးမှုကို 25-40ms ဖြစ်ပေါ်စေကြောင်းပြသထားသည်။ 99th percentile သည် အထက်ဖော်ပြပါ ရွေးချယ်ထားသော 60ms SLO နှင့် အံဝင်ခွင်ကျဖြစ်နေဆဲဖြစ်သည်။

ကုန်ကျစရိတ်၏စည်းကမ်းချက်များ၌:

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 10000 / ဆာဗာတစ်ခုလျှင် တောင်းဆိုချက် 500 ခု = ဆာဗာ 20 + 1

အရာအားလုံး တိုးတက်နိုင်သေးသည်။

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် ၅၀

ကြီးစွာသော ပစ်လွှတ်မှု။ အပလီကေးရှင်းသည် တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 1000 ကို လုပ်ဆောင်ကြောင်းပြသသော်လည်း latency ကန့်သတ်ချက်ကို SLO မှ ချိုးဖောက်ခဲ့သည်။ ၎င်းကို အပေါ်ညာဘက်ဂရပ်တွင် စာကြောင်း p99 တွင်တွေ့နိုင်ပါသည်။ p100 လိုင်းသည် များစွာမြင့်မားသော်လည်း အမှန်တကယ်နှောင့်နှေးမှုသည် အများဆုံး 60ms ထက် ပိုများသည်။ အပလီကေးရှင်း အမှန်တကယ် လုပ်ဆောင်သည်များကို သိရှိရန် ပရိုဖိုင်းဆွဲခြင်းတွင် စူးစမ်းကြည့်ကြပါစို့။

စာရင်းသွင်းခြင်း။

ပရိုဖိုင်ပြုလုပ်ရန်အတွက်၊ ကျွန်ုပ်တို့သည် ဝန်ကို တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 1000 သို့ သတ်မှတ်ပြီးနောက် အသုံးပြုသည်။ pprof အပလီကေးရှင်းသည် CPU အချိန်ကို မည်သည့်နေရာတွင် သုံးစွဲသည်ကို သိရှိရန် အချက်အလက်များကို ဖမ်းယူရန်။ HTTP အဆုံးမှတ်ကို အသက်သွင်းခြင်းဖြင့် ၎င်းကို လုပ်ဆောင်နိုင်သည်။ pprofပြီးနောက်၊ load အောက်တွင်၊ curl ကိုသုံး၍ ရလဒ်များကိုသိမ်းဆည်းပါ။

$ curl http://localhost:8080/debug/pprof/profile?seconds=29 > cpu.1000_reqs_sec_no_optimizations.prof

ရလဒ်များကို ဤကဲ့သို့ ပြသနိုင်သည်-

$ go tool pprof -http=:12345 cpu.1000_reqs_sec_no_optimizations.prof

ဂရပ်သည် အပလီကေးရှင်းသည် CPU အချိန်ကို မည်သည့်နေရာနှင့် မည်မျှသုံးစွဲသည်ကို ပြသသည်။ ဖော်ပြချက်ကနေ ဘရန်ဒန် ဂရက်ဂ်:

X ဝင်ရိုးသည် အက္ခရာစဉ်ဖြင့် စီထားသော စတက်ခ်ပရိုဖိုင်လူဦးရေ (ယခုအချိန်မဟုတ်ပါ)၊ Y ဝင်ရိုးသည် [ထိပ်) မှ သုညမှရေတွက်သည့် stack ၏အတိမ်အနက်ကိုပြသသည်။ စတုဂံတစ်ခုစီသည် stack frame တစ်ခုဖြစ်သည်။ ဘောင်ပိုကျယ်လေ၊ ၎င်းသည် stacks တွင် မကြာခဏဆိုသလို ရှိနေလေလေဖြစ်သည်။ CPU တွင် ထိပ်တန်းတွင် လုပ်ဆောင်နေသည်များ၊ နှင့် အောက်ဖော်ပြပါ အရာများသည် ကလေး အစိတ်အပိုင်းများ ဖြစ်သည်။ အရောင်များသည် အများအားဖြင့် ဘာမှ အဓိပ္ပါယ်မရှိသော်လည်း ဖရိမ်များကို ကွဲပြားစေရန် ကျပန်းဖြင့် ရွေးချယ်သည်။

ခွဲခြမ်းစိတ်ဖြာ-ယူဆချက်

ချိန်ညှိခြင်းအတွက်၊ ကျွန်ုပ်တို့သည် ဖြုန်းတီးနေသော CPU အချိန်များကို ရှာဖွေရန် အာရုံစိုက်ပါမည်။ အသုံးမဝင်သော အသုံးစရိတ်၏ အကြီးဆုံးရင်းမြစ်များကို ရှာဖွေပြီး ၎င်းတို့ကို ဖယ်ရှားပါမည်။ ကောင်းပြီ၊ ၎င်းပရိုဖိုင်းသည် အပလီကေးရှင်း၏ပရိုဆက်ဆာအချိန်ကို အတိအကျသုံးစွဲသည့်နေရာတွင် အလွန်တိကျစွာဖော်ပြသောကြောင့်၊ သင်သည် ၎င်းကို အကြိမ်များစွာပြုလုပ်ရမည်ဖြစ်ပြီး အပလီကေးရှင်းအရင်းအမြစ်ကုဒ်ကိုပြောင်းလဲရန်၊ စမ်းသပ်မှုများကို ပြန်လည်လုပ်ဆောင်ရန်နှင့် စွမ်းဆောင်ရည်သည် ပစ်မှတ်သို့ချဉ်းကပ်နေသည်ကို တွေ့မြင်ရမည်ဖြစ်သည်။

Brendan Gregg ၏အကြံပြုချက်များအတိုင်း၊ ကျွန်ုပ်တို့သည် ဇယားကို အပေါ်မှအောက်ခြေအထိဖတ်ပါမည်။ စာကြောင်းတစ်ခုစီသည် stack frame (function call) ကိုပြသသည်။ ပထမစာကြောင်းသည် ပရိုဂရမ်ထဲသို့ ဝင်သည့်အမှတ်ဖြစ်ပြီး၊ အခြားခေါ်ဆိုမှုအားလုံး၏ ပင်မဖြစ်သည် (တစ်နည်းအားဖြင့်၊ အခြားခေါ်ဆိုမှုအားလုံးသည် ၎င်းတို့၏ stack တွင် ရှိနေမည်)။ နောက်တစ်ကြောင်းက ကွဲပြားနေပြီ

အကယ်၍ သင်သည် ဂရပ်ပေါ်တွင် လုပ်ဆောင်ချက်တစ်ခု၏အမည်ပေါ်တွင် ကာဆာကို ရွှေ့ထားပါက၊ အမှားရှာပြင်နေစဉ်အတွင်း စထရပ်ပေါ်ရှိ စုစုပေါင်းအချိန်ကို ပြသပါမည်။ HTTPServe လုပ်ဆောင်ချက်သည် ထိုအချိန်၏ 65%၊ အခြား runtime လုပ်ဆောင်ချက်များ ရှိနေပါသည်။ runtime.mcall, mstart и gcကျန်တဲ့အချိန်တွေကို ယူတယ်။ ပျော်ရွှင်စရာအချက်- DNS မေးမြန်းမှုများတွင် စုစုပေါင်းအချိန်၏ 5% ကို အသုံးပြုသည်-

ပရိုဂရမ်ရှာဖွေသောလိပ်စာများသည် Postgresql နှင့်သက်ဆိုင်သည်။ ကိုနှိပ်ပါ။ FindByAge:

စိတ်ဝင်စားစရာမှာ၊ ပရိုဂရမ်သည် အခြေခံအားဖြင့် နှောင့်နှေးမှုများကို ပေါင်းထည့်သည့် အဓိက ရင်းမြစ်သုံးရပ် ဖြစ်သည်- ချိတ်ဆက်မှုများကို အဖွင့်အပိတ်၊ ဒေတာတောင်းခံခြင်းနှင့် ဒေတာဘေ့စ်သို့ ချိတ်ဆက်ခြင်းတို့ကို ပြသထားသည်။ DNS တောင်းဆိုမှုများ၊ အဖွင့်အပိတ်ချိတ်ဆက်မှုများသည် စုစုပေါင်းလုပ်ဆောင်ချိန်၏ 13% ခန့်ယူကြောင်း ဂရပ်ကပြသသည်။

ယူဆချက်- ပေါင်းစည်းခြင်းကို အသုံးပြု၍ ချိတ်ဆက်မှုများကို ပြန်လည်အသုံးပြုခြင်းသည် HTTP တောင်းဆိုချက်တစ်ခုတည်း၏ အချိန်ကို လျှော့ချသင့်ပြီး ထုတ်လွှင့်မှုပိုမိုမြင့်မားခြင်းနှင့် latency နည်းပါးခြင်းတို့ကို ခွင့်ပြုပေးပါသည်။.

အပလီကေးရှင်းကို သတ်မှတ်ခြင်း - စမ်းသပ်မှု

ကျွန်ုပ်တို့သည် အရင်းအမြစ်ကုဒ်ကို အပ်ဒိတ်လုပ်သည်၊ တောင်းဆိုချက်တစ်ခုစီအတွက် Postgresql သို့ချိတ်ဆက်မှုကို ဖယ်ရှားရန် ကြိုးစားပါ။ ပထမရွေးချယ်မှုမှာ အသုံးပြုရန်ဖြစ်သည်။ ချိတ်ဆက်မှုရေကန် လျှောက်လွှာအဆင့်မှာ။ ဒီစမ်းသပ်မှုမှာ ကျွန်တော်တို သတ်မှတ်ကြပါစို့ သွားရန်အတွက် sql driver ကို အသုံးပြု၍ ချိတ်ဆက်မှုပေါင်းစည်းခြင်း

db, err := sql.Open("postgres", dbConnectionString)
db.SetMaxOpenConns(8)

if err != nil {
   return nil, err
}

စီရင်ခြင်း၊ လေ့လာခြင်း၊ ခွဲခြမ်းစိတ်ဖြာခြင်း။

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 1000 ဖြင့် စမ်းသပ်မှုကို ပြန်လည်စတင်ပြီးနောက်၊ p99 ၏ latency အဆင့်များသည် 60ms ရှိသော SLO ဖြင့် ပုံမှန်သို့ ပြန်သွားကြောင်း ထင်ရှားပါသည်။

ကုန်ကျစရိတ်က ဘယ်လောက်လဲ။

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 10000 / ဆာဗာတစ်ခုလျှင် တောင်းဆိုချက် 1000 ခု = ဆာဗာ 10 + 1

ပိုကောင်းအောင် လုပ်ကြရအောင်။

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် ၅၀

ဝန်ကိုနှစ်ဆတိုးခြင်းက တူညီသောအရာကိုပြသသည်၊ ဘယ်ဘက်အပေါ်ပိုင်းဂရပ်တွင် အပလီကေးရှင်းသည် တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 2000 ကိုလုပ်ဆောင်နိုင်သည်၊ p100 သည် 60ms ထက်နည်းသည်၊ p99 သည် SLO ကိုကျေနပ်စေသည်။

ကုန်ကျစရိတ်၏စည်းကမ်းချက်များ၌:

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 10000 / ဆာဗာတစ်ခုလျှင် တောင်းဆိုချက် 2000 ခု = ဆာဗာ 5 + 1

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် ၅၀

ဤနေရာတွင် အပလီကေးရှင်းသည် 3000ms ထက်နည်းသော p99 latency ဖြင့် တောင်းဆိုချက် 60 ကို လုပ်ဆောင်နိုင်သည်။ SLO သည် ချိုးဖောက်ခြင်းမရှိပါ၊ ကုန်ကျစရိတ်ကို အောက်ပါအတိုင်း လက်ခံပါသည်။

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် 10000 / ဆာဗာတစ်ခုလျှင် တောင်းဆိုချက် 3000 နှုန်း = ဆာဗာ 4 ခု + 1 (စာရေးဆရာက စုစည်းထားပါတယ်၊ အနီးစပ်ဆုံး ဘာသာပြန်သူ)

နောက်ထပ် ခွဲခြမ်းစိတ်ဖြာကြည့်ရအောင်။

ခွဲခြမ်းစိတ်ဖြာ-ယူဆချက်

ကျွန်ုပ်တို့သည် အပလီကေးရှင်းကို အမှားရှာခြင်း၏ရလဒ်များကို တစ်စက္ကန့်လျှင် တောင်းဆိုမှု 3000 ဖြင့် စုဆောင်းပြသသည်-

အချိန်၏ 6% ကို ချိတ်ဆက်မှုထူထောင်ရန် သုံးစွဲနေသေးသည်။ ရေကူးကန်ကို စနစ်ထည့်သွင်းခြင်းသည် စွမ်းဆောင်ရည် ပိုမိုကောင်းမွန်လာသော်လည်း အပလီကေးရှင်းသည် ဒေတာဘေ့စ်သို့ ချိတ်ဆက်မှုအသစ်များ ဖန်တီးခြင်းတွင် ဆက်လက်လုပ်ဆောင်နေကြောင်း သင်တွေ့မြင်နိုင်သေးသည်။

ယူဆချက်- ရေကူးကန်တစ်ခုရှိနေသော်လည်း ချိတ်ဆက်မှုများကို ဖြုတ်ချပြီး သန့်ရှင်းနေသေးသောကြောင့် အက်ပ်လီကေးရှင်းမှ ၎င်းတို့ကို ပြန်လည်သတ်မှတ်ရန် လိုအပ်ပါသည်။ ရေကူးကန်အရွယ်အစားသို့ ဆိုင်းငံ့ထားသည့် ချိတ်ဆက်မှုအရေအတွက်ကို သတ်မှတ်ခြင်းသည် အပလီကေးရှင်းမှ ချိတ်ဆက်မှုဖန်တီးရာတွင် အသုံးပြုသည့်အချိန်ကို လျှော့ချခြင်းဖြင့် latency ကို ကူညီပေးသင့်သည်။.

အပလီကေးရှင်းကို သတ်မှတ်ခြင်း - စမ်းသပ်မှု

ထည့်သွင်းရန် ကြိုးစားနေပါသည်။ MaxIdleConns ရေကူးကန် အရွယ်အစားနှင့် တူညီသည် (ဖော်ပြထားသည်။ ဒီမှာ):

db, err := sql.Open("postgres", dbConnectionString)
db.SetMaxOpenConns(8)
db.SetMaxIdleConns(8)
if err != nil {
   return nil, err
}

စီရင်ခြင်း၊ လေ့လာခြင်း၊ ခွဲခြမ်းစိတ်ဖြာခြင်း။

တစ်စက္ကန့်လျှင် တောင်းဆိုချက် ၅၀

p99 သည် 60ms ထက်နည်းပြီး p100 သိသိသာသာနည်းသည်။

မီးတောက်ဂရပ်ကို စစ်ဆေးခြင်း ချိတ်ဆက်မှုမှာ သိသာထင်ရှားတော့မည်မဟုတ်ကြောင်း ပြသသည်။ နောက်ထပ်အသေးစိတ်စစ်ဆေးကြည့်ရအောင် pg(*conn).query — ဤနေရာတွင် ချိတ်ဆက်မှုကိုလည်း ကျွန်ုပ်တို့သတိမထားမိပါ။

ကောက်ချက်

ဖောက်သည်မျှော်လင့်ချက်များနှင့် လုပ်ငန်းဆောင်တာမဟုတ်သော လိုအပ်ချက်များကို ပြည့်မီကြောင်း နားလည်ရန်အတွက် စွမ်းဆောင်ရည်ပိုင်းခြားစိတ်ဖြာမှုသည် အရေးကြီးပါသည်။ ဖောက်သည်မျှော်လင့်ချက်များနှင့် စူးစမ်းလေ့လာမှုများကို နှိုင်းယှဉ်ခြင်းဖြင့် ခွဲခြမ်းစိတ်ဖြာခြင်းသည် လက်ခံနိုင်စရာနှင့် မည်သည့်အရာသည် လက်ခံနိုင်သည်ကို ဆုံးဖြတ်ရန် ကူညီပေးပါသည်။ Go သည် ခွဲခြမ်းစိတ်ဖြာမှုကို ရိုးရှင်းလွယ်ကူစွာ သုံးနိုင်စေရန် စံစာကြည့်တိုက်တွင် တည်ဆောက်ထားသော အစွမ်းထက်သောကိရိယာများကို ပံ့ပိုးပေးပါသည်။

source: www.habr.com