മനഃപൂർവം വസ്തുക്കൾ തകര് ക്കൽ: അരാജകത്വത്തിന്റെ സാങ്കേതിക വിദ്യ

എല്ലാ സിസ്റ്റത്തിനും ദുർബലതകളുണ്ട്. ഒരു ടൈം ഔട്ട് വളരെ നീണ്ടതാണ്. ഒരു ചെറിയ പ്രശ്നം വലിയ പ്രശ്നമാക്കി മാറ്റുന്ന ഒരു ശ്രമം. രണ്ടു വര് ഷം മുമ്പ് പരീക്ഷണത്തില് ഒരിക്കൽ ഫലം ചെയ്ത ഒരു ഫയല് ഓവര് , അതിനു ശേഷം ഒരിക്കലും. സാധാരണയായി, ഒരു യഥാർത്ഥ വൈദ്യുതി മുടക്കത്തില് , ഏറ്റവും മോശം സമയത്താണ് നിങ്ങള് അവരെ കണ്ടെത്തുന്നത്.

കുഴപ്പങ്ങൾ ഉണ്ടാക്കുന്നതിനു മുമ്പ്, നിയന്ത്രിതമായി, ദുർബലമായ സ്ഥലങ്ങൾ കണ്ടെത്തുക എന്നതാണ് കുഴപ്പങ്ങൾ സൃഷ്ടിക്കുന്നതിനെക്കുറിച്ചുള്ള സാങ്കേതിക വിദ്യ.

ഈ ആശയം

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

ഇന്ന് ഈ രീതി ക്രമരഹിതമായ നാശനഷ്ടങ്ങളേക്കാൾ സൂക്ഷ്മവും ശാസ്ത്രീയവുമാണ്.

1. സ്ഥിരസ്ഥിതി നിർവചിക്കുക: "സാധാരണ ജോലി" എന്നതിന് എന്ത് തോന്നുന്നു? സാധാരണയായി പിശക് നിരക്ക്, ലേറ്റൻസി, ഓർഡറുകൾ മിനിറ്റിൽ തുടങ്ങിയ അളവുകളിലൂടെയാണ് അളക്കുന്നത്.
2. ഒരു അനുമാനം ഉണ്ടാക്കുക: "ഒരു ഡാറ്റാബേസ് റെപ്ലിക്ക പരാജയപ്പെട്ടാൽ, പിശക് നിരക്ക് 0.5% നു താഴെയായി തുടരും, ആപ്ലിക്കേഷൻ 30 സെക്കൻഡിനകം വീണ്ടെടുക്കുന്നു".
3. ഒരു പരാജയം പരിചയപ്പെടുത്തുകറെപ്ലിക്കയെ കൊല്ലുക.
4. നിരീക്ഷിക്കുക: സ്ഥിരാവസ്ഥ നിലനിന്നോ?
5. പഠിക്കുകയും ശരിയാക്കുകയും ചെയ്യുകഇല്ലെങ്കില് , അത് ഒരു യഥാർത്ഥ തകരാറിന് കാരണമാകുന്നതിനു മുമ്പ് നിങ്ങള് ഒരു ദുർബലമായ സ്ഥലം കണ്ടെത്തിയിട്ടുണ്ട്.

ചാസ് എഞ്ചിനീയറിംഗ് എന്നത് ചിലതൊക്കെ തകര് ക്കുകയല്ല. നിങ്ങളുടെ സിസ്റ്റത്തിന് ഒരു ഹിറ്റ് എടുക്കാൻ കഴിയുമെന്ന് തെളിയിക്കാനും എവിടെയാണെന്ന് കണ്ടെത്താനും ആണ്.

ഏതു തരത്തിലുള്ള പരാജയങ്ങളാണ്?

സാധാരണ പരീക്ഷണങ്ങൾ:

• കോഡുകളെയോ നോഡുകളെയോ കൊല്ലുക: കുബർനെറ്റസ് ശരിയായി മാറ്റുന്നുണ്ടോ? ഉപഭോക്താക്കള് വീണ്ടും ബന്ധപ്പെടാറുണ്ടോ?
• നെറ്റ്വർക്ക് ലേറ്റൻസി കൂട്ടിച്ചേര് ക്കുക: ഒരു ആസക്തി കുറയാതെ പതുക്കെ കുറയുമ്പോൾ എന്ത് സംഭവിക്കും? (പലപ്പോഴും ദുഃഖം എന്നതിനേക്കാൾ മോശമാണ്.)
• നെറ്റ്വർക്ക് ട്രാഫിക് കുറയ്ക്കുക സേവനങ്ങള് തമ്മിലോ, ഒരു ബാഹ്യ API-യിലോ.
• ഡിസ്കുകൾ പൂരിപ്പിക്കുക അല്ലെങ്കിൽ എക്സോസ്റ്റ് മെമ്മറിയും സിപിയുവും.
• ഒരു മുഴുവൻ ലഭ്യമായ മേഖലയും പരാജയപ്പെടുത്തുക: ട്രാഫിക് മാറുന്നുണ്ടോ?
• ഡിഎൻഎസ് തകർക്കുക അല്ലെങ്കിൽ സർട്ടിഫിക്കറ്റുകളോ.
• ഒരു ആശ്രിതത്വം പിശകുകൾ തിരികെ നൽകുന്നു.

നിങ്ങളുടെ ആദ്യ കളി ദിനം

A കളി ദിവസം ഒരു സംഘം ഒരുമിച്ച് ഒരു ചാസ് പരീക്ഷണം നടത്തുന്ന ഒരു ആസൂത്രിത സെഷനാണ്. അത് ആരംഭിക്കാനുള്ള ഏറ്റവും നല്ല വഴിയാണ്.

ഞാനെങ്ങനെ ഒരു ഓട്ടം നടത്തും:

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

ആദ്യ കളി ദിവസം പലപ്പോഴും അപ്രതീക്ഷിതമായി എന്തെങ്കിലും കാണിക്കുന്നു: ഒരു അലേർട്ട് നഷ്ടപ്പെട്ടു, ഡാഷ്ബോർഡ് ആശയക്കുഴപ്പത്തിലായി, ഒരു കാലഹരണപ്പെട്ട റൺബുക്ക്, അല്ലെങ്കിൽ ഒരു വീണ്ടും ശ്രമം. അത് മാത്രം മതി അത് ചെയ്യാന് .

പരീക്ഷിക്കാൻ കഴിയുന്ന ഉപകരണങ്ങൾ

• ചാസ് മെഷ് (CNCF): ഒരു നല്ല ഇന്റർഫേസ് ഉള്ള ഒരു Kubernetes നേറ്റീവ് ടൂൾ. പരീക്ഷണങ്ങൾ കുബർനെറ്റസ് വിഭവങ്ങളാണ്: പാഡ് കൊല്ലൽ, നെറ്റ്വർക്ക് കാലതാമസം, സമ്മർദ്ദം, I/O പിഴവുകൾ, സമയ വ്യതിയാനം തുടങ്ങിയവ.
• ലിറ്റ്മസ് ചാസ് (സി. എൻ. സി. എഫ്): ഒരു വലിയ ഹബ് റെഡിമെയ്ഡ് പരീക്ഷണങ്ങളും വർക്ക്ഫ്ലോകളും ഉള്ള കുബർനെറ്റസ് കുഴപ്പങ്ങൾ.
• AWS തെറ്റായ ഇൻജക്ഷൻ സേവനം ഒപ്പം അസ്യുര് ചയോസ് സ്റ്റുഡിയോ: ക്ലൌഡ് റിസോഴ്സുകളില് പരാജയങ്ങള് , AZ ലെവല് തടസ്സങ്ങള് എന്നിവ ഉൾപ്പെടെയുള്ളവയില് പരാജയങ്ങള് സംയോജിപ്പിക്കുന്നതിനുള്ള മാനേജ് ചെയ്ത സേവനങ്ങള് .
• ഗ്രെംലിൻ: സുരക്ഷാ നിയന്ത്രണങ്ങളുള്ളതും നല്ല ഇന്റര്ഫേസ് ഉള്ളതുമായ ഒരു വാണിജ്യ പ്ലാറ്റ്ഫോം.
• ടോക്സിപ്രോക്സി: ടെസ്റ്റുകളിലെ നെറ്റ്വർക്ക് അവസ്ഥകളെ അനുകരിക്കുന്നതിനുള്ള ലളിതമായ പ്രോക്സി.

ലേറ്റൻസി കൂട്ടിച്ചേർക്കുന്ന ഒരു ചാസ് മെഷ് പരീക്ഷണം:

apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: checkout-db-latency
  namespace: shop
spec:
  action: delay
  mode: all
  selector:
    namespaces: ["shop"]
    labelSelectors:
      app: checkout
  delay:
    latency: "500ms"
    jitter: "100ms"
  direction: to
  target:
    mode: all
    selector:
      labelSelectors:
        app: orders-db
  duration: "5m"

ചെറിയ കാര്യത്തില് നിന്ന് തുടങ്ങുക, സുരക്ഷിതമായിരിക്കുക

• സ്റ്റേജിംഗ് തുടങ്ങുകചെറിയ സ്ഫോടന റേഡിയസ് ഉള്ള ഒരു പോഡ്, ഒരു സേവനം.
• പരീക്ഷണങ്ങളെ തിരിച്ചെടുക്കാവുന്നതാക്കുക സമയ പരിധിയുമുണ്ട്.
• സൂക്ഷ്മമായി നിരീക്ഷിക്കുക പ്രതീക്ഷിച്ചതിലും കൂടുതലായി കാര്യങ്ങൾ നടക്കുകയാണെങ്കില് അത് റദ്ദാക്കും.
• ആളുകളോട് പറയൂ പരീക്ഷണങ്ങൾ നടത്തുന്നതിനു മുമ്പ്, പ്രത്യേകിച്ച് ആദ്യം.
• ശ്രദ്ധയോടെ ഉല്പാദനത്തിലേക്ക് മാറുക., നിങ്ങളുടെ നിരീക്ഷണത്തിലും റോൾബാക്കിലും വിശ്വസിച്ചതിനുശേഷം മാത്രം, ജോലി സമയങ്ങളിൽ ഏറ്റവും അപകടകരമായ പരീക്ഷണങ്ങളുമായി ആരംഭിക്കുക.

അത് സഹായിച്ചോ?

കാലത്തിനനുസരിച്ച് പ്രഭാവം അളക്കുക:

• കണ്ടെത്തിയതും പരിഹരിച്ചതുമായ ദൌർബല്യങ്ങളുടെ എണ്ണം.
• നിങ്ങൾ പരീക്ഷിച്ച പരാജയ മോഡുകൾ മൂലമുണ്ടായ സംഭവങ്ങൾ (താഴ്ത്തിക്കാണണം).
• യഥാര് ത്ഥ സംഭവങ്ങളില് വീണ്ടെടുക്കൽ സമയം.
• സംഭവങ്ങളുടെ സമയത്ത് ടീമിന് ആത്മവിശ്വാസം ഉണ്ടാകും, അത് അളക്കാൻ ബുദ്ധിമുട്ടാണ്, പക്ഷെ വളരെ യാഥാർത്ഥ്യമാണ്.

നീയത് പരീക്ഷിക്കണോ?

അതെ, ചെറിയ തോതിലെങ്കിലും. ഒരു ദിവസം കളി, ഒരു ലളിതമായ പരീക്ഷണം, ഒരു ടീമിനെ അവരുടെ സിസ്റ്റത്തെക്കുറിച്ച് കൂടുതൽ പഠിപ്പിക്കുന്നു, ആർക്കൈറ്റക്ചർ ഡയഗ്രമുകൾ വായിക്കുന്നതിനേക്കാൾ.

എന്റെ അഭിപ്രായം: എല്ലാ സംവിധാനത്തിനും ഒരു തകർച്ച പോയിന്റ് ഉണ്ട്. ശനിയാഴ്ച രാത്രി തിരക്കുള്ളതിനേക്കാൾ ശാന്തമായ ചൊവ്വാഴ്ച വൈകുന്നേരം അത് കണ്ടെത്തുന്നതാണ് നല്ലത്.

ഡെസ്ലി