memcached આડી રીતે માપવા માટે mcrouter નો ઉપયોગ કરવો

કોઈપણ ભાષામાં ઉચ્ચ-લોડ પ્રોજેક્ટ્સ વિકસાવવા માટે વિશેષ અભિગમ અને વિશિષ્ટ સાધનોના ઉપયોગની જરૂર છે, પરંતુ જ્યારે PHP માં એપ્લિકેશનની વાત આવે છે, ત્યારે પરિસ્થિતિ એટલી વિકટ બની શકે છે કે તમારે વિકાસ કરવો પડશે, ઉદાહરણ તરીકે, પોતાનું એપ્લિકેશન સર્વર. આ નોંધમાં આપણે વિતરિત સત્ર સ્ટોરેજ અને મેમકેશ્ડમાં ડેટા કેશીંગ સાથે પરિચિત પીડા વિશે વાત કરીશું અને કેવી રીતે અમે એક "વોર્ડ" પ્રોજેક્ટમાં આ સમસ્યાઓનું નિરાકરણ કર્યું.

પ્રસંગનો હીરો સિમ્ફની 2.3 ફ્રેમવર્ક પર આધારિત PHP એપ્લિકેશન છે, જે અપડેટ કરવાની વ્યવસાય યોજનાઓમાં બિલકુલ સમાવિષ્ટ નથી. તદ્દન પ્રમાણભૂત સત્ર સંગ્રહ ઉપરાંત, આ પ્રોજેક્ટનો સંપૂર્ણ ઉપયોગ કર્યો "બધું કેશીંગ" નીતિ memcached માં: ડેટાબેઝ અને API સર્વર્સની વિનંતીઓના જવાબો, વિવિધ ફ્લેગ્સ, કોડ એક્ઝેક્યુશનને સિંક્રનાઇઝ કરવા માટેના તાળાઓ અને ઘણું બધું. આવી સ્થિતિમાં, મેમકૅશનું ભંગાણ એપ્લીકેશનની કામગીરી માટે ઘાતક બની જાય છે. વધુમાં, કેશ નુકશાન ગંભીર પરિણામો તરફ દોરી જાય છે: ડીબીએમએસ સીમ પર ફૂટવાનું શરૂ કરે છે, API સેવાઓ વિનંતીઓ પર પ્રતિબંધ મૂકવાનું શરૂ કરે છે, વગેરે. પરિસ્થિતિને સ્થિર કરવામાં દસ મિનિટ લાગી શકે છે, અને આ સમય દરમિયાન સેવા ભયંકર રીતે ધીમી અથવા સંપૂર્ણપણે અનુપલબ્ધ હશે.

અમારે પ્રદાન કરવાની જરૂર હતી થોડા પ્રયત્નો સાથે એપ્લિકેશનને આડા સ્કેલ કરવાની ક્ષમતા, એટલે કે સ્ત્રોત કોડમાં ન્યૂનતમ ફેરફારો અને સંપૂર્ણ કાર્યક્ષમતા સાચવેલ છે. કેશને માત્ર નિષ્ફળતાઓ માટે પ્રતિરોધક જ નહીં, પણ તેમાંથી ડેટા નુકશાન ઘટાડવાનો પણ પ્રયાસ કરો.

memcached પોતે સાથે શું ખોટું છે?

સામાન્ય રીતે, PHP માટે મેમકેશ્ડ એક્સ્ટેંશન બોક્સની બહાર વિતરિત ડેટા અને સત્ર સ્ટોરેજને સપોર્ટ કરે છે. સાતત્યપૂર્ણ કી હેશિંગ માટેની પદ્ધતિ તમને ઘણા સર્વર્સ પર સમાનરૂપે ડેટા મૂકવાની પરવાનગી આપે છે, દરેક ચોક્કસ કીને જૂથમાંથી ચોક્કસ સર્વર પર વિશિષ્ટ રીતે સંબોધિત કરે છે, અને બિલ્ટ-ઇન ફેલઓવર ટૂલ્સ કેશીંગ સેવાની ઉચ્ચ ઉપલબ્ધતાની ખાતરી કરે છે (પરંતુ, કમનસીબે, કોઈ ડેટા નથી).

સત્ર સંગ્રહ સાથે વસ્તુઓ થોડી વધુ સારી છે: તમે ગોઠવી શકો છો memcached.sess_number_of_replicas, જેના પરિણામે ડેટા એકસાથે અનેક સર્વર્સ પર સંગ્રહિત થશે, અને એક મેમકેશ્ડ દાખલાની નિષ્ફળતાના કિસ્સામાં, ડેટા અન્ય લોકો પાસેથી ટ્રાન્સફર કરવામાં આવશે. જો કે, જો સર્વર ડેટા વિના ઓનલાઈન પાછું આવે છે (જેમ કે સામાન્ય રીતે પુનઃપ્રારંભ પછી થાય છે), તો કેટલીક કી તેની તરફેણમાં પુનઃવિતરિત કરવામાં આવશે. હકીકતમાં આનો અર્થ થશે સત્ર ડેટાની ખોટ, કારણ કે ચૂકી જવાના કિસ્સામાં બીજી પ્રતિકૃતિ પર જવાનો કોઈ રસ્તો નથી.

સ્ટાન્ડર્ડ લાઇબ્રેરી ટૂલ્સનો હેતુ મુખ્યત્વે છે આડું સ્કેલિંગ: તેઓ તમને કેશને વિશાળ કદમાં વધારવા અને વિવિધ સર્વર્સ પર હોસ્ટ કરેલા કોડમાંથી તેની ઍક્સેસ પ્રદાન કરવાની મંજૂરી આપે છે. જો કે, અમારી પરિસ્થિતિમાં, સંગ્રહિત ડેટાનું પ્રમાણ ઘણા ગીગાબાઇટ્સ કરતાં વધી જતું નથી, અને એક અથવા બે નોડ્સનું પ્રદર્શન તદ્દન પર્યાપ્ત છે. તદનુસાર, કાર્યકારી સ્થિતિમાં ઓછામાં ઓછી એક કેશ દાખલાની જાળવણી કરતી વખતે memcached ની ઉપલબ્ધતા સુનિશ્ચિત કરવા માટે એકમાત્ર ઉપયોગી પ્રમાણભૂત સાધનો હોઈ શકે છે. જો કે, આ તકનો પણ લાભ ઉઠાવવો શક્ય ન હતો... અહીં પ્રોજેક્ટમાં ઉપયોગમાં લેવાતા ફ્રેમવર્કની પ્રાચીનતાને યાદ કરવા યોગ્ય છે, તેથી જ સર્વર્સના પૂલ સાથે કામ કરવા માટે એપ્લિકેશન મેળવવી અશક્ય હતી. ચાલો સત્ર ડેટાની ખોટ વિશે પણ ભૂલી ન જઈએ: વપરાશકર્તાઓના વિશાળ લોગઆઉટથી ગ્રાહકની આંખ મીંચાઈ ગઈ.

આદર્શ રીતે તે જરૂરી હતું મેમકેશ્ડ અને બાયપાસ પ્રતિકૃતિઓમાં રેકોર્ડની પ્રતિકૃતિ ભૂલ અથવા ભૂલના કિસ્સામાં. અમને આ વ્યૂહરચના લાગુ કરવામાં મદદ કરી mcrouter.

mcrouter

ફેસબુક દ્વારા તેની સમસ્યાઓ ઉકેલવા માટે વિકસાવવામાં આવેલ આ એક મેમકેશ્ડ રાઉટર છે. તે મેમકેશ્ડ ટેક્સ્ટ પ્રોટોકોલને સપોર્ટ કરે છે, જે પરવાનગી આપે છે સ્કેલ memcached સ્થાપનો પાગલ પ્રમાણ માટે. mcrouter નું વિગતવાર વર્ણન આમાં મળી શકે છે આ જાહેરાત. અન્ય વસ્તુઓ વચ્ચે વિશાળ કાર્યક્ષમતા તે આપણને જે જોઈએ છે તે કરી શકે છે:

• નકલ રેકોર્ડ;
• જો કોઈ ભૂલ થાય તો જૂથના અન્ય સર્વર્સ પર ફોલબેક કરો.

કામે લાગો!

mcrouter રૂપરેખાંકન

હું સીધા રૂપરેખા પર જઈશ:

{
 "pools": {
   "pool00": {
     "servers": [
       "mc-0.mc:11211",
       "mc-1.mc:11211",
       "mc-2.mc:11211"
   },
   "pool01": {
     "servers": [
       "mc-1.mc:11211",
       "mc-2.mc:11211",
       "mc-0.mc:11211"
   },
   "pool02": {
     "servers": [
       "mc-2.mc:11211",
       "mc-0.mc:11211",
       "mc-1.mc:11211"
 },
 "route": {
   "type": "OperationSelectorRoute",
   "default_policy": "AllMajorityRoute|Pool|pool00",
   "operation_policies": {
     "get": {
       "type": "RandomRoute",
       "children": [
         "MissFailoverRoute|Pool|pool02",
         "MissFailoverRoute|Pool|pool00",
         "MissFailoverRoute|Pool|pool01"
       ]
     }
   }
 }
}

શા માટે ત્રણ પૂલ? સર્વર શા માટે પુનરાવર્તિત થાય છે? ચાલો આકૃતિ કરીએ કે તે કેવી રીતે કાર્ય કરે છે.

• આ રૂપરેખાંકનમાં, mcrouter એ પાથ પસંદ કરે છે કે જ્યાં વિનંતી આદેશના આધારે વિનંતી મોકલવામાં આવશે. તે વ્યક્તિ તેને આ વાત કહે છે OperationSelectorRoute.
• GET વિનંતીઓ હેન્ડલર પાસે જાય છે RandomRouteજે રેન્ડમલી એરે ઑબ્જેક્ટ્સ વચ્ચે પૂલ અથવા માર્ગ પસંદ કરે છે children. આ એરેનું દરેક ઘટક બદલામાં હેન્ડલર છે MissFailoverRoute, જે પૂલના દરેક સર્વરમાંથી પસાર થશે જ્યાં સુધી તેને ડેટા સાથે પ્રતિસાદ ન મળે, જે ક્લાયંટને પરત કરવામાં આવશે.
• જો આપણે વિશિષ્ટ રીતે ઉપયોગ કરીએ છીએ MissFailoverRoute ત્રણ સર્વર્સના પૂલ સાથે, પછી બધી વિનંતીઓ પ્રથમ મેમકેશ્ડ દાખલામાં આવશે, અને બાકીની વિનંતીઓ શેષ ધોરણે પ્રાપ્ત થશે જ્યારે ડેટા ન હોય. આવા અભિગમ તરફ દોરી જશે સૂચિમાં પ્રથમ સર્વર પર અતિશય લોડ, તેથી અલગ-અલગ સિક્વન્સમાં સરનામાં સાથે ત્રણ પૂલ જનરેટ કરવાનો અને તેમને રેન્ડમલી પસંદ કરવાનું નક્કી કરવામાં આવ્યું હતું.
• અન્ય તમામ વિનંતીઓ (અને આ એક રેકોર્ડ છે) નો ઉપયોગ કરીને પ્રક્રિયા કરવામાં આવે છે AllMajorityRoute. આ હેન્ડલર પૂલમાંના તમામ સર્વરને વિનંતીઓ મોકલે છે અને તેમાંથી ઓછામાં ઓછા N/2 + 1 ના પ્રતિસાદોની રાહ જુએ છે. ઉપયોગ થી AllSyncRoute લેખન કામગીરી માટે ત્યજી દેવાની હતી, કારણ કે આ પદ્ધતિને હકારાત્મક પ્રતિસાદની જરૂર છે всех જૂથમાં સર્વર્સ - અન્યથા તે પરત આવશે SERVER_ERROR. જોકે mcrouter ઉપલબ્ધ કેશમાં ડેટા ઉમેરશે, કૉલિંગ PHP ફંક્શન ભૂલ પરત કરશે અને નોટિસ જનરેટ કરશે. AllMajorityRoute તે એટલું કડક નથી અને ઉપર વર્ણવેલ સમસ્યાઓ વિના અડધા જેટલા એકમોને સેવામાંથી બહાર કાઢવાની મંજૂરી આપે છે.

મુખ્ય ગેરલાભ આ સ્કીમ એ છે કે જો કેશમાં ખરેખર કોઈ ડેટા ન હોય, તો ક્લાયન્ટની દરેક વિનંતી માટે N મેમકેશની વિનંતીઓ ખરેખર એક્ઝિક્યુટ કરવામાં આવશે - માટે બધા માટે પૂલમાં સર્વર્સ. અમે પૂલમાં સર્વરની સંખ્યા ઘટાડી શકીએ છીએ, ઉદાહરણ તરીકે, બે સુધી: સંગ્રહની વિશ્વસનીયતા બલિદાન આપીને, અમને મળે છેоવિનંતીઓથી ખૂટતી કી સુધી વધુ ઝડપ અને ઓછો ભાર.

NB: તમે mcrouter શીખવા માટે ઉપયોગી લિંક્સ પણ શોધી શકો છો વિકિ પર દસ્તાવેજીકરણ и પ્રોજેક્ટ મુદ્દાઓ (બંધ લોકો સહિત), વિવિધ રૂપરેખાંકનોના સંપૂર્ણ સ્ટોરહાઉસનું પ્રતિનિધિત્વ કરે છે.

મેક્રોઉટર બનાવવું અને ચલાવવું

અમારી એપ્લીકેશન (અને પોતે મેમકેશ્ડ) કુબરનેટ્સમાં ચાલે છે - તદનુસાર, mcrouter પણ ત્યાં સ્થિત છે. માટે કન્ટેનર એસેમ્બલી અમે ઉપયોગ કરીએ છીએ વર્ફ, જેની રૂપરેખા આના જેવી દેખાશે:

NB: લેખમાં આપેલી યાદીઓ ભંડારમાં પ્રકાશિત થાય છે ફ્લેંટ/મક્રોઉટર.

configVersion: 1
project: mcrouter
deploy:
 namespace: '[[ env ]]'
 helmRelease: '[[ project ]]-[[ env ]]'
---
image: mcrouter
from: ubuntu:16.04
mount:
- from: tmp_dir
 to: /var/lib/apt/lists
- from: build_dir
 to: /var/cache/apt
ansible:
 beforeInstall:
 - name: Install prerequisites
   apt:
     name: [ 'apt-transport-https', 'tzdata', 'locales' ]
     update_cache: yes
 - name: Add mcrouter APT key
   apt_key:
     url: https://facebook.github.io/mcrouter/debrepo/xenial/PUBLIC.KEY
 - name: Add mcrouter Repo
   apt_repository:
     repo: deb https://facebook.github.io/mcrouter/debrepo/xenial xenial contrib
     filename: mcrouter
     update_cache: yes
 - name: Set timezone
   timezone:
     name: "Europe/Moscow"
 - name: Ensure a locale exists
   locale_gen:
     name: en_US.UTF-8
     state: present
 install:
 - name: Install mcrouter
   apt:
     name: [ 'mcrouter' ]

(werf.yaml)

... અને તેને સ્કેચ કરો સુકાન ચાર્ટ. રસપ્રદ વાત એ છે કે પ્રતિકૃતિઓની સંખ્યાના આધારે માત્ર એક રૂપરેખા જનરેટર છે (જો કોઈની પાસે વધુ લેકોનિક અને ભવ્ય વિકલ્પ હોય, તો તેને ટિપ્પણીઓમાં શેર કરો):

{{- $count := (pluck .Values.global.env .Values.memcached.replicas | first | default .Values.memcached.replicas._default | int) -}}
{{- $pools := dict -}}
{{- $servers := list -}}
{{- /* Заполняем  массив двумя копиями серверов: "0 1 2 0 1 2" */ -}}
{{- range until 2 -}}
 {{- range $i, $_ := until $count -}}
   {{- $servers = append $servers (printf "mc-%d.mc:11211" $i) -}}
 {{- end -}}
{{- end -}}
{{- /* Смещаясь по массиву, получаем N срезов: "[0 1 2] [1 2 0] [2 0 1]" */ -}}
{{- range $i, $_ := until $count -}}
 {{- $pool := dict "servers" (slice $servers $i (add $i $count)) -}}
 {{- $_ := set $pools (printf "MissFailoverRoute|Pool|pool%02d" $i) $pool -}}
{{- end -}}
---
apiVersion: v1
kind: ConfigMap
metadata:
 name: mcrouter
data:
 config.json: |
   {
     "pools": {{- $pools | toJson | replace "MissFailoverRoute|Pool|" "" -}},
     "route": {
       "type": "OperationSelectorRoute",
       "default_policy": "AllMajorityRoute|Pool|pool00",
       "operation_policies": {
         "get": {
           "type": "RandomRoute",
           "children": {{- keys $pools | toJson }}
         }
       }
     }
   }

(10-mcrouter.yaml)

અમે તેને પરીક્ષણ વાતાવરણમાં રોલ આઉટ કરીએ છીએ અને તપાસો:

# php -a
Interactive mode enabled

php > # Проверяем запись и чтение
php > $m = new Memcached();
php > $m->addServer('mcrouter', 11211);
php > var_dump($m->set('test', 'value'));
bool(true)
php > var_dump($m->get('test'));
string(5) "value"
php > # Работает! Тестируем работу сессий:
php > ini_set('session.save_handler', 'memcached');
php > ini_set('session.save_path', 'mcrouter:11211');
php > var_dump(session_start());
PHP Warning:  Uncaught Error: Failed to create session ID: memcached (path: mcrouter:11211) in php shell code:1
Stack trace:
#0 php shell code(1): session_start()
#1 {main}
  thrown in php shell code on line 1
php > # Не заводится… Попробуем задать session_id:
php > session_id("zzz");
php > var_dump(session_start());
PHP Warning:  session_start(): Cannot send session cookie - headers already sent by (output started at php shell code:1) in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Failed to write session lock: UNKNOWN READ FAILURE in php shell code on line 1
PHP Warning:  session_start(): Unable to clear session lock record in php shell code on line 1
PHP Warning:  session_start(): Failed to read session data: memcached (path: mcrouter:11211) in php shell code on line 1
bool(false)
php >

ભૂલના ટેક્સ્ટની શોધ કરવાથી કોઈ પરિણામ મળ્યું નથી, પરંતુ ક્વેરી માટે “માઇક્રોઉટર php"આગળ પર પ્રોજેક્ટની સૌથી જૂની વણઉકેલાયેલી સમસ્યા હતી - આધારનો અભાવ memcached દ્વિસંગી પ્રોટોકોલ.

NB: memcached માં ASCII પ્રોટોકોલ બાઈનરી પ્રોટોકોલ કરતા ધીમું છે, અને સુસંગત કી હેશિંગના પ્રમાણભૂત માધ્યમો ફક્ત બાઈનરી પ્રોટોકોલ સાથે જ કામ કરે છે. પરંતુ આ ચોક્કસ કેસ માટે સમસ્યા ઊભી કરતું નથી.

યુક્તિ બેગમાં છે: તમારે ફક્ત ASCII પ્રોટોકોલ પર સ્વિચ કરવાનું છે અને બધું કામ કરશે.... જો કે, આ કિસ્સામાં, માં જવાબો શોધવાની આદત php.net પર દસ્તાવેજીકરણ ક્રૂર મજાક રમી. તમને ત્યાં સાચો જવાબ મળશે નહીં... સિવાય કે, અલબત્ત, તમે અંત સુધી સ્ક્રોલ કરો, જ્યાં વિભાગમાં "વપરાશકર્તા યોગદાન નોંધો" વફાદાર રહેશે અને અયોગ્ય રીતે ડાઉનવોટેડ જવાબ.

હા, સાચો વિકલ્પ નામ છે memcached.sess_binary_protocol. તે અક્ષમ હોવું આવશ્યક છે, જેના પછી સત્રો કામ કરવાનું શરૂ કરશે. જે બાકી છે તે PHP સાથેના પોડમાં mcrouter સાથેના કન્ટેનરને મૂકવાનું છે!

નિષ્કર્ષ

આમ, માત્ર માળખાકીય ફેરફારો સાથે અમે સમસ્યાને હલ કરવામાં સક્ષમ હતા: મેમકેશ્ડ ફોલ્ટ ટોલરન્સ સાથેનો મુદ્દો ઉકેલાઈ ગયો છે, અને કેશ સ્ટોરેજની વિશ્વસનીયતામાં વધારો કરવામાં આવ્યો છે. એપ્લિકેશન માટેના સ્પષ્ટ ફાયદાઓ ઉપરાંત, આ પ્લેટફોર્મ પર કામ કરતી વખતે દાવપેચ માટે જગ્યા આપે છે: જ્યારે બધા ઘટકો પાસે અનામત હોય છે, ત્યારે એડમિનિસ્ટ્રેટરનું જીવન ખૂબ જ સરળ બને છે. હા, આ પદ્ધતિમાં તેની ખામીઓ પણ છે, તે "ક્રચ" જેવી દેખાઈ શકે છે, પરંતુ જો તે પૈસા બચાવે છે, સમસ્યાને દફનાવે છે અને નવી સમસ્યાઓનું કારણ નથી - શા માટે નહીં?

PS

અમારા બ્લોગ પર પણ વાંચો:

• "dapp સાથે પ્રેક્ટિસ કરો" (ઉદાહરણ તરીકે સિમ્ફોની-ડેમોનો ઉપયોગ કરીને): ભાગ 1 (સરળ એપ્લિકેશન બનાવવી) и ભાગ 2 (હેલ્મનો ઉપયોગ કરીને કુબરનેટ્સ પર ડોકર છબીઓ જમાવવી);
• «કુબરનેટ્સ સાથેના જીવનમાંથી: કેવી રીતે HTTP સર્વરે સ્પેનિયાર્ડ્સની તરફેણ કરી નથી».

સોર્સ: www.habr.com