അടിസ്ഥാന സൗകര്യങ്ങൾ കോഡായി കൈകാര്യം ചെയ്യുക: ടെറാഫോമും ഐഎസിയും ഉള്ള ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ്

നേട്ടങ്ങൾ:

• IaC ആശയവും ടെറാഫോമിൻ്റെ പ്രവർത്തന ചക്രവും (ഇനിറ്റ്, പ്ലാൻ, പ്രയോഗിക്കുക, സംസ്ഥാനം, മൊഡ്യൂൾ) മനസിലാക്കാനുള്ള കഴിവ്, കൂടാതെ കൃത്രിമബുദ്ധി സുരക്ഷിതമായ എച്ച്സിഎൽ ഡ്രാഫ്റ്റുകൾ നിർമ്മിക്കാനുള്ള കഴിവ്
• പ്രയോഗിക്കുന്നതിന് മുമ്പ് ഓരോ മാറ്റവും പ്ലാൻ ഉപയോഗിച്ച് പരിശോധിക്കാനും അപ്രതീക്ഷിതമായി നശിപ്പിക്കാനും/മാറ്റിസ്ഥാപിക്കാനും ഉള്ള കഴിവ്
• രഹസ്യങ്ങൾ കോഡിന് പുറത്ത് സൂക്ഷിക്കുക, അവസ്ഥ സുരക്ഷിതമായി സൂക്ഷിക്കുക, IAM അനുമതികൾ കുറയ്ക്കുക തുടങ്ങിയ തത്വങ്ങൾ പ്രയോഗിക്കാനുള്ള കഴിവ്

മുൻകാലങ്ങളിൽ, ഒരു സെർവർ സജ്ജീകരിക്കുന്നത് ഒരു ക്ലൗഡ് പാനലിലൂടെ ക്ലിക്കുചെയ്യുന്ന കാര്യമായിരുന്നു: ഒരു വെർച്വൽ മെഷീൻ സൃഷ്ടിക്കുക, നെറ്റ്‌വർക്ക് സജ്ജീകരിക്കുക, സുരക്ഷാ നിയമം ചേർക്കുക. ഈ രീതി മന്ദഗതിയിലുള്ളതും പിശക് സാധ്യതയുള്ളതും ആവർത്തിക്കാനാകാത്തതും ആയിരുന്നു - അതേ പരിതസ്ഥിതി രണ്ടാം തവണ സജ്ജീകരിക്കുന്നത് ഏതാണ്ട് അസാധ്യമായിരുന്നു. ഇന്ന്, അടിസ്ഥാന സൗകര്യങ്ങൾ കോഡായി കൈകാര്യം ചെയ്യുന്നു. IaC (Infrastructure as Code) എന്നത് ക്ലൗഡ് ഉറവിടങ്ങളായ സെർവറുകൾ, നെറ്റ്‌വർക്കുകൾ, ഡാറ്റാബേസുകൾ എന്നിവയെ മാനുവലായി എന്നതിലുപരി ടെക്സ്റ്റ് ഫയലുകളിൽ വിവരിക്കുന്നതിനുള്ള ഒരു സമീപനമാണ്. ഈ ഫയലുകൾ പതിപ്പ് നിയന്ത്രണത്തിലാണ് (Git); ആരാണ് എന്ത്, എപ്പോൾ, എന്താണ് മാറ്റിയതെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും; ഒരു കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരേ ഇൻഫ്രാസ്ട്രക്ചർ നിരവധി തവണ സജ്ജീകരിക്കാൻ കഴിയും.

ഏറ്റവും സാധാരണമായ IaC ടൂൾ ടെറാഫോം ആണ്. ടെറാഫോം എച്ച്‌സിഎൽ (ഹാഷികോർപ്പ് കോൺഫിഗറേഷൻ ലാംഗ്വേജ് - ടെറാഫോമിൻ്റെ കോൺഫിഗറേഷൻ ഭാഷ) എന്ന് വിളിക്കപ്പെടുന്ന ഒരു വായിക്കാനാകുന്ന ഭാഷയിൽ നിങ്ങൾ എഴുതുന്ന നിർവചനങ്ങൾ എടുക്കുന്നു, അവയെ ക്ലൗഡ് ദാതാവിൻ്റെ (AWS, Azure, GCP) API-യിലേക്ക് വിവർത്തനം ചെയ്യുകയും ഉറവിടങ്ങൾ സൃഷ്ടിക്കുകയും ചെയ്യുന്നു. AI-ക്ക് എച്ച്‌സിഎല്ലിനെ നന്നായി അറിയാം കൂടാതെ സങ്കീർണ്ണമായ ബ്ലോക്കുകൾ വേഗത്തിൽ നിർമ്മിക്കുകയും ചെയ്യുന്നു. എന്നാൽ IaC-ൽ, ഒരു തെറ്റിൻ്റെ വില കൂടുതലാണ്: ഒരു തെറ്റായ നിർവചനം ഒരു മുഴുവൻ പ്രൊഡക്ഷൻ ഡാറ്റാബേസും ഇല്ലാതാക്കും. അതുകൊണ്ടാണ് ടെറാഫോമിലെ സുവർണ്ണനിയമം നടപ്പാക്കുന്നതിന് മുമ്പ് ഓരോ മാറ്റവും ഒരു 'പ്ലാൻ' ഉപയോഗിച്ച് കാണുക എന്നതാണ്.

ടെറാഫോമിൻ്റെ റൺടൈം

ടെറാഫോം മൂന്ന് അടിസ്ഥാന കമാൻഡുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു - ഇവ അറിയുന്നത് AI ഔട്ട്പുട്ട് നിയന്ത്രിക്കുന്നതിന് ഒരു മുൻവ്യവസ്ഥയാണ്:

• `terraform init`: പ്രോജക്റ്റ് ആരംഭിക്കുന്നു, ആവശ്യമായ ദാതാവിൻ്റെ പ്ലഗിനുകൾ ഡൗൺലോഡ് ചെയ്യുന്നു.
• `ടെറാഫോം പ്ലാൻ`: നിലവിലെ സാഹചര്യത്തെ ആവശ്യമുള്ള സാഹചര്യവുമായി താരതമ്യപ്പെടുത്തുകയും എന്ത് ചേർക്കണം, എന്ത് മാറ്റണം, എന്ത് ഇല്ലാതാക്കണം എന്ന് കാണിക്കുകയും ചെയ്യുന്നു. ഒന്നും നടപ്പാക്കുന്നില്ല. ഏറ്റവും നിർണായകമായ സുരക്ഷാ നടപടിയാണിത്.
• `ടെറാഫോം പ്രയോഗിക്കുക`: യഥാർത്ഥത്തിൽ പ്ലാൻ പ്രയോഗിക്കുന്നു, ഉറവിടങ്ങൾ സൃഷ്ടിക്കുന്നു/പരിഷ്ക്കരിക്കുന്നു.

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

നുറുങ്ങ്: ഒരു ടെറാഫോം ഔട്ട്‌പുട്ടിലെ ഏറ്റവും അപകടകരമായ അടയാളം പ്ലാൻ ഔട്ട്‌പുട്ടിൽ നശിപ്പിക്കുക അല്ലെങ്കിൽ -/+ (മാറ്റിസ്ഥാപിക്കുക) ലൈനുകളാണ്. ഉറവിടം ഇല്ലാതാക്കപ്പെടും എന്നാണ് ഇതിനർത്ഥം. ഒരു പ്ലാനിൽ അപ്രതീക്ഷിതമായ നാശം നിങ്ങൾ കാണുകയാണെങ്കിൽ, ഒരിക്കലും പ്രയോഗിക്കരുത്, അത് പ്രത്യക്ഷപ്പെട്ടത് എന്തുകൊണ്ടാണെന്ന് ആദ്യം മനസ്സിലാക്കുക.

ഘട്ടം ഘട്ടമായി: AI ഉപയോഗിച്ച് IaC എഴുതുന്നു

1. ആവശ്യമുള്ള അടിസ്ഥാന സൗകര്യങ്ങൾ വ്യക്തമാക്കുക. "eu-central-1-ൽ ഒരു VPC, രണ്ട് സബ്‌നെറ്റുകൾ, ഒരു സുരക്ഷാ ഗ്രൂപ്പ്, ഒരു t3.micro EC2" എന്നിവ പോലെ കോൺക്രീറ്റ് ആയിരിക്കുക.
2. ദാതാവിനെയും പതിപ്പിനെയും വ്യക്തമാക്കുക. ഏത് ക്ലൗഡ്, ഏത് ടെറാഫോമും പ്രൊവൈഡർ പതിപ്പും? നിങ്ങൾ ഒരു പതിപ്പ് വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, AI കാലഹരണപ്പെട്ട/അനുയോജ്യമായ വാക്യഘടന തിരികെ നൽകിയേക്കാം.
3. HCL ഡ്രാഫ്റ്റ് ഹാജരാക്കണം. വേരിയബിളുകളും ഔട്ട്പുട്ടുകളും അഭ്യർത്ഥിക്കുക.
4. രഹസ്യം പുറത്തെടുക്കുക. പാസ്‌വേഡുകളും കീകളും പോലുള്ള മൂല്യങ്ങൾ വേരിയബിളിലേക്കും രഹസ്യ നിലവറയിലേക്കും പോകണം, കോഡിലേക്കല്ല.
5. `init` + `പ്ലാൻ` റൺ ചെയ്യുക. പ്ലാൻ ഔട്ട്പുട്ട് വരി വരിയായി വായിക്കുക; അപ്രതീക്ഷിതമായ ഇല്ലാതാക്കലുകൾ പരിശോധിക്കുക.
6. ചെറുതായി തുടങ്ങുക, ക്രമേണ നടപ്പിലാക്കുക. ഇത് ആദ്യം ഒരു ഒറ്റപ്പെട്ട ടെസ്റ്റ് അക്കൗണ്ടിൽ/പരിസ്ഥിതിയിൽ പ്രയോഗിക്കുക.

സുരക്ഷ: IaC-നിർദ്ദിഷ്ട അപകടസാധ്യതകൾ

IaC അത് ശക്തമാണ്. മൂന്ന് നിർണായക പോയിൻ്റുകൾ:

1. സംസ്ഥാന ഫയലിൽ ഒരു രഹസ്യമുണ്ട്. ടെറാഫോം അവസ്ഥ ചിലപ്പോൾ ഡാറ്റാബേസ് പാസ്‌വേഡുകൾ പോലുള്ള സെൻസിറ്റീവ് മൂല്യങ്ങൾ പ്ലെയിൻടെക്‌സ്റ്റിൽ സൂക്ഷിക്കുന്നു. ഒരിക്കലും സംസ്ഥാനത്തെ ഒരു പൊതു സംഭരണിയിൽ ഉൾപ്പെടുത്തരുത്; എൻക്രിപ്റ്റ് ചെയ്ത, നിയന്ത്രിത ആക്സസ് റിമോട്ട് ബാക്കെൻഡ് ഉപയോഗിക്കുക.
2. HCL-ൽ രഹസ്യങ്ങൾ ഉൾപ്പെടുത്തരുത്. password="prod123" പോലെയുള്ള വരികൾ Git ചരിത്രത്തിൽ ശാശ്വതമായി എഴുതിയിരിക്കുന്നു. പകരം, ഒരു വേരിയബിൾ ഉപയോഗിക്കുകയും എൻവയോൺമെൻ്റ് വേരിയബിളിൽ നിന്ന് (TF_VAR_...) അല്ലെങ്കിൽ രഹസ്യ നിലവറയിൽ നിന്ന് റൺടൈമിൽ മൂല്യം നൽകുക.
3. വളരെ വിശാലമായ IAM അനുമതി. AI ചിലപ്പോൾ ആക്ഷൻ പോലുള്ള ബ്ലോക്കുകൾ നിർമ്മിക്കുന്നു: "*" (എല്ലാം അനുവദിക്കുക) "ഇത് പ്രവർത്തിക്കാൻ". ഇതൊരു ദുർബലതയാണ്; ആവശ്യമായ ഏറ്റവും കുറഞ്ഞ അളവിലേക്ക് അനുമതി ചുരുക്കുക.

ശ്രദ്ധിക്കുക: ഒരു രഹസ്യം Git ചരിത്രത്തിൽ പ്രവേശിച്ചുകഴിഞ്ഞാൽ, അത് ഭൂതകാലത്തിൽ തന്നെ നിലനിൽക്കും, നിങ്ങൾ ഫയൽ ഇല്ലാതാക്കിയാലും വിട്ടുവീഴ്ച ചെയ്യപ്പെടാം. നിങ്ങൾ അബദ്ധത്തിൽ ചെയ്താൽ, ഉടൻ റദ്ദാക്കി രഹസ്യം തിരിക്കുക; വെറുതെ ഇല്ലാതാക്കിയാൽ പോരാ.

അപകടകരമായ പ്ലാൻ അടയാള പട്ടിക

പ്രിൻ്റൗട്ട് പ്ലാൻ ചെയ്യുക

അർത്ഥം

എന്ത് ചെയ്യണം

+സൃഷ്ടിക്കുക

പുതിയ ഉറവിടം കൂട്ടിച്ചേർക്കും

പൊതുവെ സുരക്ഷിതമാണ്, എങ്കിലും അവലോകനം ചെയ്യുക

~ സ്ഥലത്ത് അപ്ഡേറ്റ് ചെയ്യുക

സൈറ്റിൽ ഉറവിടം മാറും

ആഘാതം പരിശോധിക്കുക (ഒരു മുടക്കം ഉണ്ടാകുമോ?)

-/+ മാറ്റിസ്ഥാപിക്കുക

ഇല്ലാതാക്കി വീണ്ടും സൃഷ്ടിക്കും

ജാഗ്രത: ഡാറ്റ നഷ്ടം സംഭവിക്കാം

- നശിപ്പിക്കുക

വിഭവം നശിപ്പിക്കപ്പെടും

നിർത്തുക: നിങ്ങൾ പ്രതീക്ഷിക്കുന്നില്ലെങ്കിൽ ഒരിക്കലും പ്രയോഗിക്കരുത്

മൂന്ന് മിനി കേസുകൾ

കേസ് 1 - 3 മണിക്കൂറിനുള്ളിൽ 2 ദിവസത്തെ ജോലി. ഒരു പുതിയ ടെസ്റ്റ് എൻവയോൺമെൻ്റ് (വിപിസി, സബ്‌നെറ്റുകൾ, ആർഡിഎസ് ഡാറ്റാബേസ്, ഇസിഎസ് ക്ലസ്റ്റർ) സജ്ജീകരിക്കാൻ ഒരു ടീം ടെറാഫോം എഴുതാൻ പോകുകയായിരുന്നു, പക്ഷേ അവർ എച്ച്സിഎല്ലിലേക്ക് മാറിയിരുന്നു. അവർ ആർക്കിടെക്ചറും പതിപ്പുകളും AI-ക്ക് വിവരിക്കുകയും ഒരു മോഡുലാർ ബ്ലൂപ്രിൻ്റ് നിർമ്മിക്കുകയും ചെയ്തു. അവർ പ്ലാൻ ഉപയോഗിച്ച് ഓരോ മൊഡ്യൂളും പരിശോധിച്ചുറപ്പിക്കുകയും 3 മണിക്കൂറിനുള്ളിൽ അത് പ്രവർത്തിപ്പിക്കുകയും ചെയ്തു; ഇത് അവർക്ക് രണ്ട് ദിവസത്തെ സ്വമേധയാലുള്ള ട്രയലും പിശകും എടുക്കും.

കേസ് 2 - പ്ലാൻ ഇല്ലാതാക്കി. AI- ജനറേറ്റുചെയ്‌ത അപ്‌ഡേറ്റ് കോഡ് പ്രയോഗിക്കാതെ ഒരു എഞ്ചിനീയർ ഒരു പ്ലാൻ നടത്തി. പ്രൊഡക്ഷൻ ഡാറ്റാബേസിനായി മാറ്റിസ്ഥാപിക്കുക -/+ എന്ന ഔട്ട്‌പുട്ടിൽ അടങ്ങിയിരിക്കുന്നു - മാറ്റിസ്ഥാപിക്കാനാവാത്ത ഒരു ഫീൽഡ് മാറ്റിസ്ഥാപിക്കാൻ AI ശ്രമിച്ചു, അതായത് ഡാറ്റാബേസ് ഇല്ലാതാക്കുകയും പുനഃസൃഷ്ടിക്കുകയും ചെയ്യുന്നു. എഞ്ചിനീയർ അപേക്ഷ നിർത്തുകയും സുരക്ഷിതമായ രീതിയിലേക്ക് മാറ്റുകയും ചെയ്തു. ആസൂത്രണ ശീലം ഒരു ദുരന്തത്തെ തടഞ്ഞു.

കേസ് 3 - കുഴിച്ചിട്ട രഹസ്യ ചോർച്ച. ഒരു ജൂനിയർ, YZ db_password = "S3cret!" അയാൾ വരി അതേപടി കമ്മിറ്റ് ചെയ്തു തള്ളി. കോഡ് അവലോകനത്തിൽ കുടുങ്ങി; പാസ്‌വേഡ് ഉടൻ റദ്ദാക്കുകയും മാറ്റി, മൂല്യം ഒരു വേരിയബിളിലേക്ക് മാറ്റുകയും രഹസ്യ നിലവറയിൽ നിന്ന് നൽകുകയും ചെയ്തു. പാഠം: HCL-ൽ ഒരിക്കലും പ്ലെയിൻ ടെക്സ്റ്റ് രഹസ്യങ്ങൾ ഇല്ല.

പകർത്താവുന്ന നാല് ടെംപ്ലേറ്റുകൾ

1) ഇൻഫ്രാസ്ട്രക്ചർ ഡ്രാഫ്റ്റ് സൃഷ്ടിക്കുന്നു:

ഇനിപ്പറയുന്ന അടിസ്ഥാന സൗകര്യങ്ങൾ [CLOUD: AWS]-ൽ Terraform (പതിപ്പ് ~> 1.7) ഉപയോഗിച്ച് എഴുതുക: [SOURCE LIST]. മേഖല [X]. നിയമങ്ങൾ:- എല്ലാ സെൻസിറ്റീവ് മൂല്യങ്ങളും വേരിയബിൾ ആക്കുക, അവ HCL-ൽ ഉൾച്ചേർക്കരുത്.- ദാതാവിൻ്റെ പതിപ്പ് ശരിയാക്കുക (required_providers).- IAM അനുമതികൾ ചെറുതാക്കുക, "*" ഉപയോഗിക്കരുത്.- ഔട്ട്പുട്ടായി [X, Y] തിരികെ നൽകുക. കോഡ് മോഡുലറായും വിശദീകരണങ്ങളോടും കൂടി നൽകുക.

2) പ്ലാൻ ഔട്ട്പുട്ട് വ്യാഖ്യാനിക്കുന്നു:

താഴെയുള്ള 'ടെറാഫോം പ്ലാൻ' ഔട്ട്പുട്ട് വിശകലനം ചെയ്യുക. എന്നെ പട്ടികപ്പെടുത്തുക:(1) ഏതൊക്കെ ഉറവിടങ്ങളാണ് ചേർത്തത്/മാറ്റിയത്/ഇല്ലാതാക്കിയത്,(2) ഡാറ്റ നഷ്‌ടമോ തടസ്സമോ ഉണ്ടാകാനുള്ള സാധ്യതയുള്ള വരികൾ,(3) അപേക്ഷിക്കുന്നതിന് മുമ്പ് ഞാൻ ചോദിക്കേണ്ട 3 ചോദ്യങ്ങൾ. പ്ലാൻ: [ഔട്ട്‌പുട്ട്]

3) സുരക്ഷയ്ക്കായി നിലവിലുള്ള HCL പരിശോധിക്കുക:

സുരക്ഷയ്ക്കായി ഇനിപ്പറയുന്ന ടെറാഫോം കോഡ് പരിശോധിക്കുക: ഉൾച്ചേർത്ത രഹസ്യം, അതിവിശാലമായ IAM അനുമതി, തുറന്ന നെറ്റ്‌വർക്ക് നിയമം (0.0.0.0/0), എൻക്രിപ്റ്റ് ചെയ്യാത്ത സംഭരണം? ഓരോ കണ്ടെത്തലും പ്രാധാന്യത്തിൻ്റെയും തിരുത്തലിൻ്റെയും ക്രമത്തിൽ എഴുതുക. കോഡ്: [HCL]

4) ആവർത്തന കോഡ് മൊഡ്യൂളിലേക്ക് പരിവർത്തനം ചെയ്യുക:

ഇനിപ്പറയുന്ന ആവർത്തന ടെറാഫോം കോഡ് വീണ്ടും ഉപയോഗിക്കാവുന്ന മൊഡ്യൂളിലേക്ക് പരിവർത്തനം ചെയ്യുക: ഏത് മൂല്യങ്ങളാണ് വേരിയബിളുകൾ ആയിരിക്കണം, മൊഡ്യൂൾ ഇൻ്റർഫേസ് എന്തായിരിക്കണം? ഉപയോഗത്തിൻ്റെ ഉദാഹരണവും കാണിക്കുക. കോഡ്: [HCL]

ദുർബലമായ പ്രോംപ്റ്റ് / ശക്തമായ പ്രോംപ്റ്റ്

ദുർബലമായത്: "Terraform ഉപയോഗിച്ച് ഒരു ഡാറ്റാബേസ് സൃഷ്‌ടിക്കുക."

ഫലം: ഏത് ക്ലൗഡ്, ഏത് എഞ്ചിൻ, ഏത് പതിപ്പ്, എൻക്രിപ്റ്റ് ചെയ്തിട്ടുണ്ടോ ഇല്ലയോ എന്ന് വ്യക്തമല്ല; ലെഗസി വാക്യഘടന ഉപയോഗിച്ച്, കോഡിലേക്ക് പാസ്‌വേഡ് ഉൾച്ചേർക്കുന്ന പൊതുവായി ലഭ്യമായ ഒരു ഉദാഹരണം നൽകാൻ AI-ക്ക് കഴിയും.

ശക്തം: "Terraform ~> 1.7 ഉപയോഗിച്ച് AWS-ൽ ഒരു RDS PostgreSQL 15 ഉദാഹരണം സൃഷ്‌ടിക്കുക. പാസ്‌വേഡ് വേരിയബിൾ ആക്കുക, കോഡിൽ അത് ഉൾച്ചേർക്കരുത്. സംഭരണം എൻക്രിപ്റ്റ് ചെയ്‌തതാണ്, സ്വകാര്യ സബ്‌നെറ്റിൽ നിന്ന് മാത്രമേ ആക്‌സസ് ചെയ്യാനാകൂ, പൊതുവായതല്ല, ദാതാവിൻ്റെ പതിപ്പ് ശരിയാക്കുക. ഔട്ട്‌പുട്ടായി എൻഡ്‌പോയിൻ്റ് തിരികെ നൽകുക."

വ്യത്യാസം: രണ്ടാമത്തെ പ്രോംപ്റ്റ് എഞ്ചിൻ, പതിപ്പ്, എൻക്രിപ്ഷൻ, നെറ്റ്‌വർക്ക് നിയന്ത്രണവും രഹസ്യ നിയമവും നൽകുന്നു - ഔട്ട്‌പുട്ട് സുരക്ഷിതവും പ്രോഡിനോട് അടുത്തതുമാണ്.

സാധാരണ തെറ്റുകൾ

• ഒരു `പ്ലാൻ` ഉണ്ടാക്കാതെ `അപേക്ഷിക്കാൻ`. IaC-യിലെ ഏറ്റവും ചെലവേറിയ തെറ്റ്; എപ്പോഴും ആദ്യം ആസൂത്രണം ചെയ്യുക.
• HCL-ൽ ഉൾച്ചേർത്ത രഹസ്യം. Git ചരിത്രത്തിലേക്ക് സ്ഥിരമായ ചോർച്ച സൃഷ്ടിക്കുന്നു.
• സംസ്ഥാനം സുരക്ഷിതമല്ല സംഭരിക്കുന്നു. എൻക്രിപ്റ്റ് ചെയ്യാത്ത, അൺലോക്ക് ചെയ്യാത്ത, പൊതു അവസ്ഥ ഒരു ദുരന്തമാണ്.
• പതിപ്പ് ശരിയാക്കുന്നില്ല. ഒരു പതിപ്പ് വ്യക്തമാക്കാതെ ദാതാവിനെ ഉപയോഗിക്കുന്നത് ഭാവിയിൽ പെട്ടെന്നുള്ള പരാജയങ്ങളിലേക്ക് നയിക്കും.
• *`ആക്ഷൻ: ""` പോലെയുള്ള വിശാലമായ അനുമതി.** കുറഞ്ഞ പ്രത്യേകാവകാശം എന്ന തത്വം ലംഘിക്കുന്നു.
• അപ്രതീക്ഷിതമായ `നശിപ്പിക്കൽ` അവഗണിക്കുന്നു. ചോദ്യം ചെയ്യാതെ തന്നെ പ്ലാനിലെ ഡിലീറ്റ് ലൈനുകൾ പ്രയോഗിക്കുന്നു.

ചുരുക്കത്തിൽ

IaC ഇൻഫ്രാസ്ട്രക്ചറിനെ ആവർത്തിക്കാവുന്നതും പതിപ്പിക്കാവുന്നതും ഓഡിറ്റബിൾ കോഡാക്കി മാറ്റുന്നു; ഏറ്റവും സാധാരണമായ ഉപകരണം ടെറാഫോം ആണ്. AI വേഗത്തിൽ HCL സ്റ്റബുകൾ നിർമ്മിക്കുന്നു, എന്നാൽ നിങ്ങൾ പതിപ്പ്, ക്ലൗഡ്-നിർദ്ദിഷ്ട വിശദാംശങ്ങൾ, സുരക്ഷാ നിയമങ്ങൾ എന്നിവ നൽകണം. ടെറാഫോമിലെ തെറ്റില്ലാത്ത നിയമം: ഒരു പ്ലാൻ ഉപയോഗിച്ച് എല്ലാ മാറ്റങ്ങളും കാണാനും, അപ്രതീക്ഷിതമായ ഇല്ലാതാക്കലുകൾ അന്വേഷിക്കാനും, രഹസ്യങ്ങൾ കോഡിൽ നിന്ന് അകറ്റി നിർത്താനും സംസ്ഥാനം സുരക്ഷിതമായി സൂക്ഷിക്കാനും. പ്ലാൻ ഔട്ട്‌പുട്ടിലെ നശിപ്പിച്ചതും മാറ്റിസ്ഥാപിക്കുന്നതുമായ വരികൾ വളരെ ശ്രദ്ധയോടെ വായിക്കേണ്ട സ്ഥലങ്ങളാണ്.

ആപ്ലിക്കേഷൻ ടാസ്ക്

മുകളിലെ "ഇൻഫ്രാസ്ട്രക്ചർ സ്കെച്ച് സൃഷ്ടിക്കുക" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് ഒരു ചെറിയ ഇൻഫ്രാസ്ട്രക്ചർ (ഉദാ. ഒരു സ്റ്റോറേജ് ബക്കറ്റും ഒരു ആക്സസ് പോളിസിയും) സൃഷ്ടിക്കാൻ AI-യെ അനുവദിക്കുക. തുടർന്ന്: (1) "വെറ്റിംഗ്" ടെംപ്ലേറ്റ് രഹസ്യമോ ​​* അനുമതികൾക്കായി കോഡിൽ ഉൾച്ചേർത്ത് പരിശോധിക്കുക; (2) സാധ്യമെങ്കിൽ, ഒരു ടെസ്റ്റ് അക്കൗണ്ടിൽ init + പ്ലാൻ റൺ ചെയ്ത് "പ്ലാൻ ഇൻ്റർപ്രെറ്റേഷൻ" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് പ്ലാൻ ഔട്ട്പുട്ട് വായിക്കുക; (3) അപ്രതീക്ഷിതമായ ഇല്ലാതാക്കലുകൾ/മാറ്റങ്ങൾ ശ്രദ്ധിക്കുക.

ചെക്ക്ലിസ്റ്റ്

• [ ] ഞാൻ എൻ്റെ നിർദ്ദേശത്തിൽ ക്ലൗഡ്, ടെറാഫോം/ദാതാവിൻ്റെ പതിപ്പ്, എൻക്രിപ്ഷൻ/നെറ്റ്‌വർക്ക് നിയന്ത്രണങ്ങൾ എന്നിവ ചേർത്തു.
• [ ] കോഡിൽ പ്ലെയിൻ ടെക്സ്റ്റ് രഹസ്യമില്ല; കൃത്യമായ മൂല്യങ്ങൾ വേരിയബിൾ.
• [ ] ഞാൻ IAM/അനുമതികൾ ഏറ്റവും കുറഞ്ഞ അനുമതികളായി ചുരുക്കി, * ഞാനത് ഉപയോഗിച്ചില്ല.
• [ ] പ്രയോഗിക്കുന്നതിന് മുമ്പ് ഞാൻ പ്ലാൻ റൺ ചെയ്യുകയും ഔട്ട്‌പുട്ട് ലൈൻ വരി വരി വായിക്കുകയും ചെയ്തു.
• [ ] പ്ലാനിൽ അപ്രതീക്ഷിത നാശം/പകരം ഒന്നും ഇല്ലെന്ന് ഞാൻ പരിശോധിച്ചു.
• [ ] സംസ്ഥാനം എൻക്രിപ്റ്റുചെയ്‌തതും പൂട്ടിയതും നിയന്ത്രിതവുമായ ഒരു ബാക്കെൻഡിലാണ് സൂക്ഷിച്ചിരിക്കുന്നതെന്ന് എനിക്ക് ഉറപ്പുണ്ട്.