ആരെങ്കിലും കൺസോളിൽ ക്ലിക്ക് ചെയ്തു: ഡ്രീഫ്റ്റ് പരിഹരിക്കുക

സമയം വൈകിട്ട് 4 മണി. വെള്ളിയാഴ്ച. ഉല്പാദനം വളരെ പതുക്കെയാണ്. ആരെങ്കിലും ക്ലൌഡ് കൺസോൾ തുറന്ന് ഡാറ്റാബേസ് ഇൻസ്റ്റൻസിൻറെ വലിപ്പം വർദ്ധിപ്പിക്കുന്നു, വാരാന്ത്യം കടക്കാന് വേണ്ടി മാത്രം. അത് പ്രവർത്തിക്കുന്നു. എല്ലാവരും ആശ്വാസം കൊണ്ട് വീട്ടിലേക്കു പോകുന്നു.

മൂന്നു ആഴ്ചയ്ക്കു ശേഷം, ആരോ ഓടി വന്നു. terraform apply ഒരു ബന്ധമില്ലാത്ത മാറ്റത്തിന് വേണ്ടി. ടെറഫോർം ഡാറ്റാബേസ് കോഡ് പറയുന്നതിലും വലുതാണെന്ന് കാണുന്നു, അത് സഹായകരമായി ചുരുക്കുന്നു. ഉല്പാദനം വീണ്ടും കുറയുന്നു, എന്തുകൊണ്ട് എന്ന് ആർക്കും മനസ്സിലാകുന്നില്ല.

അതാണ് ഡ്രിഫ്റ്റ്: നിങ്ങളുടെ ഇൻഫ്രാസ്ട്രക്ചർ കോഡ് പറയുന്നതും യഥാർത്ഥത്തിൽ നിലനിൽക്കുന്നതും തമ്മിലുള്ള വ്യത്യാസം.

എവിടെ നിന്നാണ് ഈ വഞ്ചന വന്നത്?

• മാനുവൽ ഹോട്ട്ഫിക്സുകൾ സംഭവങ്ങളുടെ സമയത്ത് കൺസോളില് .
• പെട്ടെന്നുള്ള പരീക്ഷണങ്ങൾ അത് താൽക്കാലികമായിരിക്കണം.
• മറ്റു ഉപകരണങ്ങള് ഒരേ വിഭവങ്ങൾ മാറ്റുന്നു: ഓട്ടോ സ്കേലറുകൾ, ക്ലൌഡ് മാനേജ്ഡ് സ്ഥിരസ്ഥിതികൾ, ടാഗുകൾ ചേർക്കുന്ന സുരക്ഷാ ഉപകരണങ്ങൾ.
• അറിയാത്ത ആളുകൾ ഒരു റിസോഴ്സ് കോഡ് ഉപയോഗിച്ച് നിയന്ത്രിക്കപ്പെടുന്നു.
• പരാജയപ്പെട്ടതോ ഭാഗികമായോ പ്രയോഗിക്കുന്നു അത് കാര്യങ്ങൾ പകുതി മാറിപ്പോയി.

ചില വള്ളങ്ങൾ അപകടകാരികളല്ല. ചിലത് അപകടകരമാണ്: ഒരു സുരക്ഷാ ഗ്രൂപ്പ് "താൽക്കാലികമായി" തുറന്നു, ഡീബഗ്ഗിംഗിനായി ഒരു എൻക്രിപ്ഷൻ ക്രമീകരണം ഓഫാക്കി.

ഡ്രീഫ്റ്റ് ഒരു സാങ്കേതിക പ്രശ്നമല്ല. സമ്മർദ്ദത്തിനിടെ ആളുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതും നിങ്ങളുടെ പ്രക്രിയ അവർ എങ്ങനെ പ്രവർത്തിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നതും തമ്മിലുള്ള വിടവാണ്.

അത് കണ്ടെത്തുക

പ്ലാനുകൾ. ഏറ്റവും ലളിതമായ രീതി: ഓടുക terraform plan ഓരോ സംസ്ഥാനത്തിനും ഒരു ഷെഡ്യൂളില് (രാത്രിക്ക് സാധാരണമാണ്), മാറ്റങ്ങള് കാണിക്കുന്ന പക്ഷം അലേര് ട്ട് ചെയ്യുക. പുറത്തുകടക്കാനുള്ള കോഡ് ഉപയോഗിക്കുക:

terraform plan -detailed-exitcode -lock=false
# exit code 0 = no changes
# exit code 1 = error
# exit code 2 = changes detected (drift, or unapplied code)

നിങ്ങളുടെ സ്റ്റാക്കുകളിലും സ്ലാക്കിലുമുള്ള ഒരു ചെറിയ ഐ. ഐ ജോലി പലപ്പോഴും മതിയാകും.

പുതുക്കിയ പ്ലാനുകൾ മാത്രം. terraform plan -refresh-only നിങ്ങളുടെ കോഡിലെ മാറ്റങ്ങളൊന്നും ഇടപെടാതെ യഥാർത്ഥ ലോകത്ത് എന്തെല്ലാം മാറ്റങ്ങൾ സംഭവിച്ചു എന്ന് മാത്രം കാണിക്കുന്നു.

പ്ലാറ്റ്ഫോമുകൾ. ഹെച് സി പി ടെറാഫോർം, സ്പേസ് ലിഫ്റ്റ്, എൻവിഎം, സ്കാൽര് തുടങ്ങിയവയിൽ ഡാഷ്ബോർഡുകളും ഷെഡ്യൂൾ ചെയ്ത പരിശോധനകളും ഉള്ള ഡ്രീഫ്റ്റ് ഡിറ്റക്ഷന് സംവിധാനമുണ്ട്.

ക്ലൌഡ് നേറ്റീവ് ഉപകരണങ്ങള് . AWS കോൺഫിഗറേഷൻ, അസ്യുര് പോളിസി, സമാന സേവനങ്ങൾ എന്നിവ കോഡ് ഉപയോഗിച്ച് കൈകാര്യം ചെയ്യാത്ത റിസോഴ്സുകൾ ഉൾപ്പെടെയുള്ള റിസോര് സുകളിലേക്കും അനുയോജ്യമല്ലാത്ത കോൺഫിഗ്രേഷനുകളിലേക്കും മാറ്റങ്ങൾ ഫ്ലാഗ് ചെയ്യാം.

അത് ശരിയാക്കുന്നു

നീങ്ങുന്നതൊക്കെ രണ്ടു വഴികളിലൂടെയാണു പോകുന്നത്:

1. കോഡ് വിജയിക്കുന്നുമാനുവൽ മാറ്റം ഒരു തെറ്റായിരുന്നു. ഓടിപ്പോകുക. apply പ്രഖ്യാപിച്ച അവസ്ഥ പുനഃസ്ഥാപിക്കാൻ.
2. യാഥാര് ത്ഥ്യം വിജയിക്കുന്നു: മാനുവൽ മാറ്റം ശരിയായിരുന്നു (വലിയ ഡാറ്റാബേസ് പോലെ). കോഡ് അപ്ഡേറ്റ് ചെയ്യുക, apply മാറ്റങ്ങളൊന്നും കാണിക്കുന്നില്ല.

പ്രധാന കാര്യം മനഃപൂർവ്വം തീരുമാനമെടുക്കുക എന്നതാണ്. ഒരിക്കലും ഓടിപ്പോകരുത്. apply അന്ധമായി ഒരു കുത്തകയിൽ ഇരിക്കുകയാണ്, എന്തൊക്കെ മാറ്റങ്ങൾ സംഭവിക്കുമെന്ന് മനസിലാക്കാതെ. പ്ലാൻ വായിക്കൂ.

പൂർണ്ണമായും കൈകൊണ്ട് സൃഷ്ടിച്ച വിഭവങ്ങളുടെ കാര്യത്തിൽ, അവയെ കൈകാര്യം ചെയ്യാന് ഇറക്കുമതി ബ്ലോക്കുകൾ:

import {
  to = aws_s3_bucket.legacy_logs
  id = "acme-legacy-logs"
}

പിന്നെ terraform plan -generate-config-out=generated.tf നിങ്ങൾക്ക് വേണ്ടി ഒരു ആദ്യ ഡ്രാഫ്റ്റ് എഴുതാനും കഴിയും.

തടയുക

കണ്ടുപിടിക്കൽ നല്ലതാണ്. പ്രതിരോധം നല്ലതാണ്:

• സ്ഥിരസ്ഥിതിയായി വായന മാത്രമുള്ള കൺസോൾ ആക്സസ്. മിക്ക ആളുകള് ക്കും പ്രൊഡക്ഷന് കൺസോളുകളില് റൈറ്റ് ആക്സസ് ആവശ്യമില്ല. അടിയന്തിര സാഹചര്യങ്ങളിൽ ലോഗ് ചെയ്യാനും അലേർട്ട് ചെയ്യാനും ഗ്ലാസ് ബ്രേക്ക് റോളുകൾ ഉപയോഗിക്കുക.
• അടിയന്തിര മാറ്റങ്ങൾക്കുള്ള വേഗതയേറിയ പാത. കോഡ് മാറ്റാനും ആപ്ലിക്കേഷനും ഒരു മണിക്കൂർ എടുത്താൽ ആളുകൾ കൺസോൾ ഉപയോഗിക്കും. കോഡ് പാത്ത് അപകടങ്ങൾക്കായി വേഗത്തിലാക്കുക.
• സംഭവത്തിനു ശേഷം നടപടി സ്വീകരിക്കുക. ആരെങ്കിലും മാനുവൽ അറ്റകുറ്റപ്പണി നടത്തിയെങ്കിൽ, പോസ്റ്റ്മോർട്ടത്തിൽ "കോഡ് അപ്ഡേറ്റ് ചെയ്യുക" എന്നതു ഉൾപ്പെടും.
• ടാഗ് നിയന്ത്രിത വിഭവങ്ങൾ (managed_by = terraform) അങ്ങനെ ആളുകൾക്ക് അവയെ തൊടരുതെന്ന് അറിയാം.
• നയങ്ങൾ ഏറ്റവും അപകടകരമായ മാനുവൽ മാറ്റങ്ങൾ പൂർണ്ണമായും തടയുന്നതിന് AWS SCP, Azure Policy എന്നിവയോ സമാനമായവയോ ഉപയോഗിച്ച്.
• ഉപയോഗം ignore_changes സൂക്ഷിച്ചു നോക്കൂ. മറ്റ് സിസ്റ്റങ്ങൾ നിയമാനുസൃതമായി കൈകാര്യം ചെയ്യുന്ന ആട്രിബ്യൂട്ടുകൾക്കായി, ഒരു ഓട്ടോ സ്കെയിലിംഗ് ഗ്രൂപ്പിന്റെ ആവശ്യമുള്ള ശേഷി പോലുള്ളവ.

lifecycle {
  ignore_changes = [desired_capacity]
}

എത്രത്തോളം വഴുതിപ്പോകും?

ചില തരംഗങ്ങൾ എപ്പോഴും ഉണ്ടാകും, പ്രത്യേകിച്ച് അപകടങ്ങളുടെ സമയത്ത്. ലക്ഷ്യം പൂജ്യം ഡ്രീഫ് അല്ല. ഒരു ദിവസത്തിനകം അത് അറിയുകയും മനഃപൂർവ്വം അത് പരിഹരിക്കുകയും ചെയ്യുക എന്നതാണ്. രാത്രിയിൽ ഒരു ഡ്രൈവ് ചെക്ക്, പിന്നെ മാനുവൽ അറ്റകുറ്റപ്പണികൾക്കു ശേഷം കോഡ് അപ്ഡേറ്റ് ചെയ്യാനുള്ള ശീലം, മിക്കവാറും നിങ്ങളെ വഴിയിൽ എത്തിക്കും.

എന്റെ അഭിപ്രായം: കൺസോൾ ശത്രുവല്ല. നീ ചെയ്തതെന്തെന്ന് മറന്നു പോകുന്നത്. നേരത്തേ വഴുതിപ്പോകൽ കണ്ടുപിടിക്കുക. സത്യത്തിന്റെ ആസ്ഥാനമായി കോഡ് ഉണ്ടാക്കുക.

ഡെസ്ലി