mcrouter ഉപയോഗിച്ച് മെംകാച്ച് തിരശ്ചീനമായി സ്കെയിൽ ചെയ്യുന്നു

ഏത് ഭാഷയിലും ഉയർന്ന-ലോഡ് പ്രോജക്റ്റുകൾ വികസിപ്പിക്കുന്നതിന് ഒരു പ്രത്യേക സമീപനവും പ്രത്യേക ഉപകരണങ്ങളുടെ ഉപയോഗവും ആവശ്യമാണ്, എന്നാൽ PHP-യിലെ ആപ്ലിക്കേഷനുകളുടെ കാര്യം വരുമ്പോൾ, സ്ഥിതിഗതികൾ വളരെ വഷളാകുകയും നിങ്ങൾ വികസിപ്പിക്കുകയും വേണം, ഉദാഹരണത്തിന്, സ്വന്തം ആപ്ലിക്കേഷൻ സെർവർ. ഈ കുറിപ്പിൽ, ഡിസ്ട്രിബ്യൂട്ടഡ് സെഷൻ സ്റ്റോറേജും മെംകാഷെഡിലെ ഡാറ്റ കാഷിംഗും ഉള്ള പരിചിതമായ വേദനയെക്കുറിച്ചും ഒരു “വാർഡ്” പ്രോജക്റ്റിൽ ഞങ്ങൾ ഈ പ്രശ്നങ്ങൾ എങ്ങനെ പരിഹരിച്ചതിനെക്കുറിച്ചും സംസാരിക്കും.

സിംഫണി 2.3 ചട്ടക്കൂടിനെ അടിസ്ഥാനമാക്കിയുള്ള ഒരു PHP ആപ്ലിക്കേഷനാണ് ഈ അവസരത്തിലെ നായകൻ, അത് അപ്‌ഡേറ്റ് ചെയ്യാനുള്ള ബിസിനസ് പ്ലാനുകളിൽ ഉൾപ്പെടുത്തിയിട്ടില്ല. തികച്ചും സ്റ്റാൻഡേർഡ് സെഷൻ സ്റ്റോറേജിന് പുറമേ, ഈ പ്രോജക്റ്റ് പൂർണ്ണമായി ഉപയോഗിച്ചു "എല്ലാം കാഷിംഗ്" നയം memcached-ൽ: ഡാറ്റാബേസ്, API സെർവറുകളിലേക്കുള്ള അഭ്യർത്ഥനകൾ, വിവിധ ഫ്ലാഗുകൾ, കോഡ് എക്സിക്യൂഷൻ സമന്വയിപ്പിക്കുന്നതിനുള്ള ലോക്കുകൾ എന്നിവയും അതിലേറെയും. അത്തരമൊരു സാഹചര്യത്തിൽ, memcached ന്റെ തകർച്ച ആപ്ലിക്കേഷന്റെ പ്രവർത്തനത്തിന് മാരകമാകും. കൂടാതെ, കാഷെ നഷ്ടം ഗുരുതരമായ പ്രത്യാഘാതങ്ങളിലേക്ക് നയിക്കുന്നു: DBMS സീമുകളിൽ പൊട്ടിത്തെറിക്കാൻ തുടങ്ങുന്നു, API സേവനങ്ങൾ അഭ്യർത്ഥനകൾ നിരോധിക്കാൻ തുടങ്ങുന്നു. സ്ഥിതി സുസ്ഥിരമാക്കുന്നതിന് പതിനായിരക്കണക്കിന് മിനിറ്റുകൾ എടുത്തേക്കാം, ഈ സമയത്ത് സേവനം വളരെ മന്ദഗതിയിലായിരിക്കും അല്ലെങ്കിൽ പൂർണ്ണമായും ലഭ്യമല്ല.

ഞങ്ങൾക്ക് നൽകേണ്ടതായിരുന്നു ചെറിയ പ്രയത്നത്തിലൂടെ ആപ്ലിക്കേഷൻ തിരശ്ചീനമായി സ്കെയിൽ ചെയ്യാനുള്ള കഴിവ്, അതായത്. സോഴ്സ് കോഡിലെ കുറഞ്ഞ മാറ്റങ്ങളോടെയും പൂർണ്ണമായ പ്രവർത്തനക്ഷമതയും സംരക്ഷിച്ചിരിക്കുന്നു. കാഷെ പരാജയങ്ങളെ പ്രതിരോധിക്കുക മാത്രമല്ല, അതിൽ നിന്നുള്ള ഡാറ്റാ നഷ്ടം കുറയ്ക്കാനും ശ്രമിക്കുക.

മെംകാഷ് ചെയ്തതിൽ എന്താണ് തെറ്റ്?

പൊതുവേ, പി‌എച്ച്‌പിയ്‌ക്കായുള്ള മെംകാഷ് ചെയ്‌ത വിപുലീകരണം ബോക്‌സിന് പുറത്ത് വിതരണം ചെയ്ത ഡാറ്റയെയും സെഷൻ സംഭരണത്തെയും പിന്തുണയ്‌ക്കുന്നു. സ്ഥിരമായ കീ ഹാഷിംഗിനുള്ള സംവിധാനം, പല സെർവറുകളിലും ഡാറ്റ തുല്യമായി സ്ഥാപിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, ഗ്രൂപ്പിൽ നിന്നുള്ള ഒരു നിർദ്ദിഷ്ട സെർവറിലേക്ക് ഓരോ നിർദ്ദിഷ്ട കീയും അദ്വിതീയമായി അഭിസംബോധന ചെയ്യുന്നു, കൂടാതെ ബിൽറ്റ്-ഇൻ പരാജയ ഉപകരണങ്ങൾ കാഷിംഗ് സേവനത്തിന്റെ ഉയർന്ന ലഭ്യത ഉറപ്പാക്കുന്നു (പക്ഷേ, നിർഭാഗ്യവശാൽ, ഡാറ്റാ ഇല്ല).

സെഷൻ സ്റ്റോറേജിൽ കാര്യങ്ങൾ കുറച്ചുകൂടി മെച്ചമാണ്: നിങ്ങൾക്ക് കോൺഫിഗർ ചെയ്യാം memcached.sess_number_of_replicas, അതിന്റെ ഫലമായി ഡാറ്റ ഒരേസമയം നിരവധി സെർവറുകളിൽ സംഭരിക്കപ്പെടും, കൂടാതെ ഒരു മെംകാഷ് ചെയ്ത സന്ദർഭം പരാജയപ്പെട്ടാൽ, ഡാറ്റ മറ്റുള്ളവരിൽ നിന്ന് കൈമാറും. എന്നിരുന്നാലും, ഡാറ്റ ഇല്ലാതെ സെർവർ ഓൺലൈനിൽ തിരിച്ചെത്തിയാൽ (സാധാരണയായി പുനരാരംഭിച്ചതിന് ശേഷം സംഭവിക്കുന്നത് പോലെ), ചില കീകൾ അതിന് അനുകൂലമായി പുനർവിതരണം ചെയ്യപ്പെടും. വാസ്തവത്തിൽ ഇത് അർത്ഥമാക്കും സെഷൻ ഡാറ്റ നഷ്ടം, നഷ്ടമായാൽ മറ്റൊരു പകർപ്പിലേക്ക് "പോകാൻ" ഒരു മാർഗവുമില്ല.

സ്റ്റാൻഡേർഡ് ലൈബ്രറി ടൂളുകൾ പ്രധാനമായും ലക്ഷ്യമിടുന്നത് തിരശ്ചീനമായി സ്കെയിലിംഗ്: കാഷെ ഭീമാകാരമായ വലുപ്പത്തിലേക്ക് വർദ്ധിപ്പിക്കാനും വ്യത്യസ്ത സെർവറുകളിൽ ഹോസ്റ്റ് ചെയ്‌തിരിക്കുന്ന കോഡിൽ നിന്ന് അതിലേക്ക് ആക്‌സസ് നൽകാനും അവ നിങ്ങളെ അനുവദിക്കുന്നു. എന്നിരുന്നാലും, ഞങ്ങളുടെ സാഹചര്യത്തിൽ, സംഭരിച്ച ഡാറ്റയുടെ അളവ് നിരവധി ജിഗാബൈറ്റുകൾ കവിയരുത്, ഒന്നോ രണ്ടോ നോഡുകളുടെ പ്രകടനം മതിയാകും. അതനുസരിച്ച്, പ്രവർത്തനാവസ്ഥയിൽ കുറഞ്ഞത് ഒരു കാഷെ ഇൻസ്‌റ്റൻസെങ്കിലും നിലനിർത്തിക്കൊണ്ടുതന്നെ മെംകാഷെഡിന്റെ ലഭ്യത ഉറപ്പാക്കുക എന്നതാണ് ഉപയോഗപ്രദമായ സ്റ്റാൻഡേർഡ് ടൂളുകൾ. എന്നിരുന്നാലും, ഈ അവസരം പോലും പ്രയോജനപ്പെടുത്താൻ കഴിഞ്ഞില്ല ... ഇവിടെ പ്രോജക്റ്റിൽ ഉപയോഗിച്ച ചട്ടക്കൂടിന്റെ പഴക്കം ഓർക്കുന്നത് മൂല്യവത്താണ്, അതിനാലാണ് സെർവറുകളുടെ ഒരു കൂട്ടം പ്രവർത്തിക്കാൻ ആപ്ലിക്കേഷൻ നേടുന്നത് അസാധ്യമായത്. സെഷൻ ഡാറ്റ നഷ്‌ടപ്പെടുന്നതിനെക്കുറിച്ചും നാം മറക്കരുത്: ഉപയോക്താക്കളുടെ വൻതോതിലുള്ള ലോഗ്ഔട്ടിൽ നിന്ന് ഉപഭോക്താവിന്റെ കണ്ണ് വിറച്ചു.

ആദർശപരമായി അത് ആവശ്യമായിരുന്നു മെംകാഷ് ചെയ്തതും ബൈപാസ് ചെയ്യുന്നതുമായ പകർപ്പുകളിലെ റെക്കോർഡുകളുടെ പകർപ്പ് ഒരു തെറ്റ് അല്ലെങ്കിൽ തെറ്റ് സംഭവിച്ചാൽ. ഈ തന്ത്രം നടപ്പിലാക്കാൻ ഞങ്ങളെ സഹായിച്ചു 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-ന്റെ ഓരോ അഭ്യർത്ഥനയ്ക്കും memcached-ലേക്കുള്ള അഭ്യർത്ഥനകൾ യഥാർത്ഥത്തിൽ നടപ്പിലാക്കും - to എല്ലാവർക്കും കുളത്തിലെ സെർവറുകൾ. പൂളുകളിലെ സെർവറുകളുടെ എണ്ണം നമുക്ക് കുറയ്ക്കാം, ഉദാഹരണത്തിന്, രണ്ടായി: സംഭരണ ​​വിശ്വാസ്യത ത്യജിച്ചാൽ, നമുക്ക് ലഭിക്കുന്നുоഅഭ്യർത്ഥനകളിൽ നിന്ന് നഷ്‌ടമായ കീകളിലേക്കുള്ള ഉയർന്ന വേഗതയും കുറഞ്ഞ ലോഡും.

NB: mcrouter പഠിക്കുന്നതിനുള്ള ഉപയോഗപ്രദമായ ലിങ്കുകളും നിങ്ങൾക്ക് കണ്ടെത്താം വിക്കിയിലെ ഡോക്യുമെന്റേഷൻ и പദ്ധതി പ്രശ്നങ്ങൾ (അടഞ്ഞവ ഉൾപ്പെടെ), വിവിധ കോൺഫിഗറേഷനുകളുടെ മുഴുവൻ സംഭരണശാലയെ പ്രതിനിധീകരിക്കുന്നു.

mcrouter നിർമ്മിക്കുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു

ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ (കൂടാതെ memcached തന്നെ) Kubernetes-ൽ പ്രവർത്തിക്കുന്നു - അതനുസരിച്ച്, mcrouter അവിടെയും സ്ഥിതിചെയ്യുന്നു. വേണ്ടി കണ്ടെയ്നർ അസംബ്ലി ഞങ്ങൾ ഉപയോഗിക്കുന്നു വെർഫ്, കോൺഫിഗറേഷൻ ഇതുപോലെ കാണപ്പെടും:

NB: ലേഖനത്തിൽ നൽകിയിരിക്കുന്ന ലിസ്റ്റിംഗുകൾ ശേഖരത്തിൽ പ്രസിദ്ധീകരിച്ചിട്ടുണ്ട് ഫ്ലാന്റ് / mcrouter.

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 >

പിശകിന്റെ വാചകം തിരയുന്നത് ഫലങ്ങളൊന്നും നൽകിയില്ല, പക്ഷേ “” എന്ന ചോദ്യത്തിന്mcrouter php"പദ്ധതിയുടെ പരിഹരിക്കപ്പെടാത്ത ഏറ്റവും പഴയ പ്രശ്നം മുന്നിലായിരുന്നു - പിന്തുണയുടെ അഭാവം memcached ബൈനറി പ്രോട്ടോക്കോൾ.

NB: memcached-ലെ ASCII പ്രോട്ടോക്കോൾ ബൈനറിയെക്കാൾ വേഗത കുറവാണ്, സ്ഥിരമായ കീ ഹാഷിംഗിന്റെ സ്റ്റാൻഡേർഡ് മാർഗങ്ങൾ ബൈനറി പ്രോട്ടോക്കോളിൽ മാത്രമേ പ്രവർത്തിക്കൂ. എന്നാൽ ഇത് ഒരു പ്രത്യേക കേസിന് പ്രശ്നങ്ങൾ സൃഷ്ടിക്കുന്നില്ല.

ട്രിക്ക് ബാഗിലുണ്ട്: നിങ്ങൾ ചെയ്യേണ്ടത് ASCII പ്രോട്ടോക്കോളിലേക്ക് മാറുക, എല്ലാം പ്രവർത്തിക്കും.... എന്നിരുന്നാലും, ഈ സാഹചര്യത്തിൽ, ഉത്തരം തിരയുന്ന ശീലം php.net-ലെ ഡോക്യുമെന്റേഷൻ ക്രൂരമായ തമാശ കളിച്ചു. നിങ്ങൾക്ക് അവിടെ ശരിയായ ഉത്തരം കണ്ടെത്താനാകില്ല... തീർച്ചയായും, നിങ്ങൾ അവസാനം വരെ സ്ക്രോൾ ചെയ്യുന്നില്ലെങ്കിൽ, വിഭാഗത്തിൽ എവിടെയാണ് "ഉപയോക്താവ് സംഭാവന ചെയ്ത കുറിപ്പുകൾ" വിശ്വസ്തനും ആയിരിക്കും അന്യായമായി വോട്ട് ചെയ്ത ഉത്തരം.

അതെ, ശരിയായ ഓപ്ഷന്റെ പേര് memcached.sess_binary_protocol. ഇത് പ്രവർത്തനരഹിതമാക്കിയിരിക്കണം, അതിനുശേഷം സെഷനുകൾ പ്രവർത്തിക്കാൻ തുടങ്ങും. PHP ഉള്ള ഒരു പോഡിലേക്ക് mcrouter ഉള്ള കണ്ടെയ്നർ ഇടുക മാത്രമാണ് അവശേഷിക്കുന്നത്!

തീരുമാനം

അതിനാൽ, അടിസ്ഥാന സൗകര്യപരമായ മാറ്റങ്ങളിലൂടെ ഞങ്ങൾക്ക് പ്രശ്നം പരിഹരിക്കാൻ കഴിഞ്ഞു: മെംകാഷ് ചെയ്ത തെറ്റ് സഹിഷ്ണുതയുമായി ബന്ധപ്പെട്ട പ്രശ്നം പരിഹരിച്ചു, കാഷെ സംഭരണത്തിന്റെ വിശ്വാസ്യത വർദ്ധിപ്പിച്ചു. ആപ്ലിക്കേഷന്റെ വ്യക്തമായ ഗുണങ്ങൾക്ക് പുറമേ, പ്ലാറ്റ്ഫോമിൽ പ്രവർത്തിക്കുമ്പോൾ ഇത് കൗശലത്തിന് ഇടം നൽകി: എല്ലാ ഘടകങ്ങളും ഒരു കരുതൽ ഉള്ളപ്പോൾ, അഡ്മിനിസ്ട്രേറ്ററുടെ ജീവിതം വളരെ ലളിതമാക്കുന്നു. അതെ, ഈ രീതിക്ക് അതിന്റെ പോരായ്മകളും ഉണ്ട്, അത് ഒരു "ക്രച്ച്" പോലെ തോന്നാം, പക്ഷേ അത് പണം ലാഭിക്കുകയും പ്രശ്നം കുഴിച്ചിടുകയും പുതിയവയ്ക്ക് കാരണമാകാതിരിക്കുകയും ചെയ്യുന്നുവെങ്കിൽ - എന്തുകൊണ്ട്?

പി.എസ്

ഞങ്ങളുടെ ബ്ലോഗിലും വായിക്കുക:

• "ഡാപ്പ് ഉപയോഗിച്ച് പരിശീലിക്കുക" (സിംഫണി-ഡെമോ ഉദാഹരണമായി ഉപയോഗിക്കുന്നു): ഭാഗം 1 (ലളിതമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കൽ) и ഭാഗം 2 (ഹെൽം ഉപയോഗിച്ച് കുബർനെറ്റസിലേക്ക് ഡോക്കർ ചിത്രങ്ങൾ വിന്യസിക്കുന്നു);
• «കുബർനെറ്റസിനൊപ്പമുള്ള ജീവിതത്തിൽ നിന്ന്: HTTP സെർവർ സ്പെയിൻകാരെ എങ്ങനെ അനുകൂലിച്ചില്ല".

അവലംബം: www.habr.com