નફો:
- IaC કોન્સેપ્ટ અને ટેરાફોર્મના કાર્ય ચક્રને સમજવાની ક્ષમતા (init, plan, apply, state, મોડ્યુલ) અને કૃત્રિમ બુદ્ધિમત્તા સુરક્ષિત HCL ડ્રાફ્ટ બનાવે છે
- અરજી કરતા પહેલા દરેક ફેરફારને પ્લાન સાથે તપાસવાની અને અનપેક્ષિત નાશ/બદલો લાઇન પકડવાની ક્ષમતા
- કોડની બહાર રહસ્યો રાખવા, રાજ્યને સુરક્ષિત રાખવા અને IAM પરવાનગીઓ ઘટાડવાના સિદ્ધાંતોને લાગુ કરવાની ક્ષમતા
ભૂતકાળમાં, સર્વર સેટ કરવું એ ક્લાઉડ પેનલ દ્વારા ક્લિક કરવાની બાબત હતી: વર્ચ્યુઅલ મશીન બનાવો, નેટવર્ક સેટ કરો, સુરક્ષા નિયમ ઉમેરો. આ પદ્ધતિ ધીમી, ભૂલથી ભરેલી અને પુનરાવર્તિત ન થઈ શકે તેવી હતી — તે જ વાતાવરણને બીજી વખત સેટ કરવું લગભગ અશક્ય હતું. આજે, ઈન્ફ્રાસ્ટ્રક્ચર કોડ તરીકે સંચાલિત થાય છે. IaC (કોડ તરીકે ઈન્ફ્રાસ્ટ્રક્ચર) એ ક્લાઉડ સંસાધનો જેમ કે સર્વર્સ, નેટવર્ક્સ અને ડેટાબેસેસને ટેક્સ્ટ ફાઈલોમાં મેન્યુઅલી નહીં પણ વર્ણવવાનો અભિગમ છે. આ ફાઇલો વર્ઝન કંટ્રોલમાં બેસે છે (Git); તમે જોઈ શકો છો કે કોણે શું, ક્યારે અને શું બદલ્યું છે; તમે એક જ આદેશ સાથે, બરાબર એ જ રીતે, ઘણી વખત સમાન ઈન્ફ્રાસ્ટ્રક્ચર સેટ કરી શકો છો.
સૌથી સામાન્ય IaC ટૂલ ટેરાફોર્મ છે. ટેરાફોર્મ તમે HCL (હાશીકોર્પ કન્ફિગરેશન લેંગ્વેજ — ટેરાફોર્મની કન્ફિગરેશન લેંગ્વેજ) નામની વાંચી શકાય તેવી ભાષામાં લખો છો તે વ્યાખ્યાઓ લે છે, તેને ક્લાઉડ પ્રોવાઈડર (AWS, Azure, GCP) API માં અનુવાદિત કરે છે અને સંસાધનો બનાવે છે. AI HCL ને સારી રીતે જાણે છે અને ઝડપથી જટિલ બ્લોક્સ બનાવે છે. પરંતુ IaC માં, ભૂલની કિંમત વધારે છે: એક ખોટી વ્યાખ્યા સમગ્ર ઉત્પાદન ડેટાબેઝને ભૂંસી શકે છે. એટલા માટે ટેરાફોર્મમાં સુવર્ણ નિયમ એ છે કે દરેક ફેરફારને અમલમાં મૂકતા પહેલા તેને 'યોજના' સાથે જોવો.
ટેરાફોર્મનો રનટાઇમ
ટેરાફોર્મ ત્રણ મૂળભૂત આદેશો સાથે કામ કરે છે - AI આઉટપુટને નિયંત્રિત કરવા માટે આ એક પૂર્વશરત છે તે જાણવું:
- `ટેરાફોર્મ ઇનિટ`: પ્રોજેક્ટ શરૂ કરે છે, જરૂરી પ્રદાતા પ્લગઇન્સ ડાઉનલોડ કરે છે.
- `ટેરાફોર્મ પ્લાન`: વર્તમાન પરિસ્થિતિને ઇચ્છિત પરિસ્થિતિ સાથે સરખાવે છે અને બતાવે છે કે શું ઉમેરવું, શું બદલવું, શું કાઢી નાખવું. કંઈપણ અમલમાં મૂકતું નથી. તે સૌથી મહત્વપૂર્ણ સુરક્ષા પગલું છે.
- `ટેરાફોર્મ લાગુ`: વાસ્તવમાં યોજના લાગુ કરે છે, સંસાધનો બનાવી/સંશોધિત કરે છે.
વધુમાં, બે ખ્યાલો મહત્વપૂર્ણ છે. સ્ટેટ (સ્ટેટ ફાઇલ): આ તે ફાઇલ છે જ્યાં ટેરાફોર્મ તેના દ્વારા સંચાલિત સંસાધનોની વર્તમાન સ્થિતિ રાખે છે; તે સામાન્ય રીતે દૂરસ્થ અને લૉક વેરહાઉસમાં સંગ્રહિત થાય છે જેથી બે લોકો તેને એક જ સમયે બદલી અથવા નાશ ન કરી શકે. મોડ્યુલ: ફરીથી વાપરી શકાય તેવું રૂપરેખાંકન પેકેજ; ઉદાહરણ તરીકે, તમે ઘણા પ્રોજેક્ટ્સમાં "નેટવર્ક સેટ કરો" મોડ્યુલનો ઉપયોગ કરી શકો છો.
ટીપ: ટેરાફોર્મ આઉટપુટમાં સૌથી ખતરનાક નિશાની એ પ્લાન આઉટપુટમાં લાઈનોનો નાશ અથવા -/+ (બદલો) છે. આનો અર્થ એ છે કે સંસાધન કાઢી નાખવામાં આવશે. જો તમે કોઈ યોજનામાં અણધાર્યો વિનાશ જોશો, તો ક્યારેય અરજી કરો, પહેલા તે શા માટે દેખાયું તે સમજો.
સ્ટેપ બાય સ્ટેપ: AI સાથે IaC લખવું
- ઇચ્છિત ઇન્ફ્રાસ્ટ્રક્ચર સ્પષ્ટ કરો. eu-central-1 પર "એક VPC, બે સબનેટ, એક સુરક્ષા જૂથ અને એક t3.micro EC2" જેવા નક્કર બનો.
- પ્રદાતા અને સંસ્કરણનો ઉલ્લેખ કરો. કયો ક્લાઉડ, કયો ટેરાફોર્મ અને પ્રોવાઇડર વર્ઝન? જો તમે સંસ્કરણનો ઉલ્લેખ ન કરો, તો AI જૂના/અસંગત વાક્યરચના પરત કરી શકે છે.
- HCL ડ્રાફ્ટ તૈયાર કરાવો. ચલ અને આઉટપુટની પણ વિનંતી કરો.
- ગુપ્ત બહાર કાઢો. પાસવર્ડ્સ અને કી જેવા મૂલ્યો વેરિયેબલ અને સિક્રેટ વૉલ્ટમાં જવા જોઈએ, કોડમાં નહીં.
- `init` + `પ્લાન` ચલાવો. લાઇન દ્વારા યોજના આઉટપુટ લાઇન વાંચો; અનપેક્ષિત કાઢી નાખવા માટે તપાસો.
- નાની શરૂઆત કરો, ધીમે ધીમે અમલ કરો. તેને પહેલા એક અલગ ટેસ્ટ એકાઉન્ટ/પર્યાવરણમાં લાગુ કરો.
સુરક્ષા: IaC-વિશિષ્ટ જોખમો
IaC તેટલું જ જોખમી છે જેટલું તે શક્તિશાળી છે. ત્રણ નિર્ણાયક મુદ્દાઓ:
- રાજ્યની ફાઇલમાં એક રહસ્ય છે. ટેરાફોર્મ સ્ટેટ કેટલીકવાર સાદા ટેક્સ્ટમાં ડેટાબેઝ પાસવર્ડ્સ જેવા સંવેદનશીલ મૂલ્યો રાખે છે. રાજ્યને ક્યારેય જાહેર ભંડારમાં ન મૂકશો; એન્ક્રિપ્ટેડ, પ્રતિબંધિત-એક્સેસ રિમોટ બેકએન્ડનો ઉપયોગ કરો.
- HCL માં રહસ્યો એમ્બેડ કરશો નહીં. Password="prod123" જેવી લીટીઓ કાયમ માટે Git ઇતિહાસમાં લખવામાં આવે છે. તેના બદલે, ચલનો ઉપયોગ કરો અને પર્યાવરણ વેરીએબલ (TF_VAR_...) અથવા સિક્રેટ વૉલ્ટમાંથી રનટાઇમ પર મૂલ્ય આપો.
- ખૂબ વ્યાપક IAM પરવાનગી. AI કેટલીકવાર એક્શન જેવા બ્લોક્સ બનાવે છે: "*" (બધું જ મંજૂરી આપો) "તેને કામ કરવા". આ એક નબળાઈ છે; પરવાનગીને જરૂરી ન્યૂનતમ સુધી સંકુચિત કરો.
ધ્યાન આપો: એકવાર ગુપ્ત ગિટ ઇતિહાસમાં પ્રવેશે છે, તે ભૂતકાળમાં રહે છે અને તમે ફાઇલ કાઢી નાખો તો પણ તેની સાથે ચેડા થઈ શકે છે. જો તમે ભૂલથી કમિટ કરો છો, તો તરત જ રદ કરો અને ગુપ્તને ફેરવો; માત્ર કાઢી નાખવું પૂરતું નથી.
જોખમી યોજના ચિહ્નો ટેબલ
યોજના પ્રિન્ટઆઉટ
અર્થ
શું કરવું
+બનાવો
નવા સંસાધન ઉમેરવામાં આવશે
સામાન્ય રીતે સલામત, છતાં સમીક્ષા કરો
~ જગ્યાએ અપડેટ કરો
સ્ત્રોત સાઇટ પર બદલાશે
અસર ચકાસો (શું આઉટેજ હશે?)
-/+ બદલો
કાઢી નાખવામાં આવશે અને ફરીથી બનાવવામાં આવશે
સાવધાન: ડેટા નુકશાન થઈ શકે છે
- નાશ
સંસાધનનો નાશ થશે
રોકો: જો તમે તેની અપેક્ષા ન રાખતા હોવ તો ક્યારેય અરજી કરશો નહીં
ત્રણ નાના કેસો
કેસ 1 - 3 કલાકમાં 2 દિવસનું કામ. એક ટીમ નવા ટેસ્ટ એન્વાયર્નમેન્ટ (VPC, સબનેટ, RDS ડેટાબેઝ, ECS ક્લસ્ટર) સેટ કરવા માટે ટેરાફોર્મ લખવા જઈ રહી હતી પરંતુ તેઓ માત્ર HCLમાં જ ગયા હતા. તેઓએ AI માં આર્કિટેક્ચર અને સંસ્કરણોનું વર્ણન કર્યું અને મોડ્યુલર બ્લુપ્રિન્ટ તૈયાર કરી. તેઓએ યોજના સાથે દરેક મોડ્યુલની ચકાસણી કરી અને તેને 3 કલાકમાં ચાલુ કરી દીધું; તે તેમને મેન્યુઅલ ટ્રાયલ અને ભૂલના બે દિવસ લેશે.
કેસ 2 - યોજનાને કાઢી નાખવામાં આવી. એક એન્જિનિયરે AI-જનરેટેડ અપડેટ કોડ લાગુ કર્યા વિના પ્લાન ચલાવ્યો. આઉટપુટમાં પ્રોડક્શન ડેટાબેઝ માટે રિપ્લેસ -/+ સમાવિષ્ટ છે - AI એ બિન-બદલી ન શકાય તેવા ફીલ્ડને બદલવાનો પ્રયાસ કર્યો, જેનો અર્થ ડેટાબેઝને કાઢી નાખવા અને ફરીથી બનાવવાનો હતો. એન્જિનિયરે અરજી કરવાનું બંધ કર્યું અને ફેરફારને સુરક્ષિત પદ્ધતિમાં બદલ્યો. આયોજનની આદતએ આફતને અટકાવી.
કેસ 3 - દફનાવવામાં આવેલ ગુપ્ત લીક. એક જુનિયર, YZ દ્વારા જારી કરાયેલ db_password = "S3cret!" તેણે જેમ છે તેમ લાઈન બાંધી અને તેને દબાણ કર્યું. કોડ સમીક્ષામાં પકડાયો; પાસવર્ડ તરત જ રદ કરવામાં આવ્યો હતો અને બદલાયો હતો, મૂલ્યને ચલમાં ખસેડવામાં આવ્યું હતું અને ગુપ્ત તિજોરીમાંથી ખવડાવવામાં આવ્યું હતું. પાઠ: HCLમાં ક્યારેય સાદા લખાણ રહસ્યો હોતા નથી.
ચાર નકલ કરી શકાય તેવા નમૂનાઓ
1) ઈન્ફ્રાસ્ટ્રક્ચર ડ્રાફ્ટ જનરેટ કરવું:
ટેરાફોર્મ (સંસ્કરણ ~> 1.7) સાથે [ક્લાઉડ: AWS] પર નીચેનું ઇન્ફ્રાસ્ટ્રક્ચર લખો: [સોર્સ સૂચિ]. પ્રદેશ [X]. નિયમો:- તમામ સંવેદનશીલ મૂલ્યોને ચલ બનાવો, તેમને HCLમાં એમ્બેડ કરશો નહીં.- પ્રદાતા સંસ્કરણને ઠીક કરો (જરૂરી_પ્રોવિડર્સ).- IAM પરવાનગીઓ ઓછી કરો, "*" નો ઉપયોગ કરશો નહીં.- આઉટપુટ તરીકે [X, Y] પરત કરો. મોડ્યુલર રીતે અને સમજૂતી સાથે કોડ આપો.
2) યોજનાના આઉટપુટનું અર્થઘટન:
નીચે 'ટેરાફોર્મ પ્લાન' આઉટપુટનું વિશ્લેષણ કરો. મને સૂચિબદ્ધ કરો:(1) કયા સંસાધનો ઉમેરવામાં આવ્યા/બદલવામાં આવ્યા/કાઢી નાખવામાં આવ્યા, (2) ડેટાના નુકશાન અથવા વિક્ષેપના જોખમે પંક્તિઓ, (3) 3 પ્રશ્નો મારે અરજી કરતા પહેલા પૂછવા જોઈએ. યોજના: [આઉટપુટ]
3) સુરક્ષા માટે હાલની HCL ની તપાસ કરો:
સુરક્ષા માટે નીચેનો ટેરાફોર્મ કોડ તપાસો: એમ્બેડેડ સિક્રેટ, વધુ પડતી વ્યાપક IAM પરવાનગી, ઓપન નેટવર્ક નિયમ (0.0.0.0/0), એનક્રિપ્ટેડ સ્ટોરેજ? દરેક શોધને મહત્વ અને સુધારણાના ક્રમમાં લખો. કોડ: [HCL]
4) પુનરાવર્તિત કોડને મોડ્યુલમાં કન્વર્ટ કરો:
નીચેના પુનરાવર્તિત ટેરાફોર્મ કોડને ફરીથી વાપરી શકાય તેવા મોડ્યુલમાં રૂપાંતરિત કરો: કયા મૂલ્યો ચલ હોવા જોઈએ, મોડ્યુલ ઈન્ટરફેસ શું હોવું જોઈએ? ઉદાહરણનો ઉપયોગ પણ બતાવો. કોડ: [HCL]
નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ
નબળા: "ટેરાફોર્મ સાથે ડેટાબેઝ બનાવો."
પરિણામ: સ્પષ્ટ નથી કે કયું વાદળ, કયું એન્જિન, કયું સંસ્કરણ, એન્ક્રિપ્ટેડ છે કે નહીં; લેગસી સિન્ટેક્સ સાથે, AI સાર્વજનિક રૂપે ઉપલબ્ધ ઉદાહરણ પ્રદાન કરી શકે છે જે કોડમાં પાસવર્ડને એમ્બેડ કરે છે.
મજબૂત: "Terraform ~> 1.7 સાથે AWS પર RDS PostgreSQL 15 દાખલો બનાવો. પાસવર્ડ વેરિયેબલ બનાવો, તેને કોડમાં એમ્બેડ કરશો નહીં. સ્ટોરેજ એન્ક્રિપ્ટેડ છે, ફક્ત ખાનગી સબનેટથી જ ઍક્સેસિબલ છે, સાર્વજનિક નથી. પ્રદાતા સંસ્કરણને ઠીક કરો. આઉટપુટ તરીકે અંતિમ બિંદુ પરત કરો."
તફાવત: બીજો પ્રોમ્પ્ટ એન્જિન, સંસ્કરણ, એન્ક્રિપ્શન, નેટવર્ક અવરોધ અને ગુપ્ત નિયમ આપે છે — આઉટપુટ સુરક્ષિત છે અને ઉત્પાદનની નજીક છે.
સામાન્ય ભૂલો
- `યોજના` બનાવ્યા વિના `અરજી` કરવી. IaC માં સૌથી મોંઘી ભૂલ; હંમેશા પ્રથમ યોજના બનાવો.
- HCL માં એમ્બેડિંગ સિક્રેટ. Git ઇતિહાસમાં કાયમી લિકેજ બનાવે છે.
- રાજ્યને અસુરક્ષિત સંગ્રહિત કરવું. એક અનક્રિપ્ટેડ, અનલૉક, જાહેર રાજ્ય એક આપત્તિ છે.
- સંસ્કરણને ઠીક કરી રહ્યું નથી. સંસ્કરણનો ઉલ્લેખ કર્યા વિના પ્રદાતાનો ઉપયોગ કરવાથી ભવિષ્યમાં અચાનક નિષ્ફળતાઓ થશે.
- *`ક્રિયા: વ્યાપક પરવાનગી જેમ કે ""`.** ઓછામાં ઓછા વિશેષાધિકારના સિદ્ધાંતનું ઉલ્લંઘન કરે છે.
- અણધાર્યા `નષ્ટ`ને અવગણવું. પ્રશ્ન કર્યા વિના યોજનામાં કાઢી નાખવાની રેખાઓ લાગુ કરવી.
સારાંશમાં
IaC ઇન્ફ્રાસ્ટ્રક્ચરને રિપીટેબલ, વર્ઝનેબલ અને ઓડિટેબલ કોડમાં ફેરવે છે; સૌથી સામાન્ય સાધન ટેરાફોર્મ છે. AI ઝડપથી HCL સ્ટબ્સ બનાવે છે, પરંતુ તમારે વર્ઝન, ક્લાઉડ-વિશિષ્ટ વિગતો અને સુરક્ષા નિયમો પ્રદાન કરવા આવશ્યક છે. ટેરાફોર્મમાં અચૂક નિયમ: દરેક ફેરફારને પ્લાન સાથે જોવા માટે, અનપેક્ષિત કાઢી નાખવાની ક્વેરી કરવા, કોડથી રહસ્યોને દૂર રાખવા અને રાજ્યને સુરક્ષિત રાખવા માટે. પ્લાન આઉટપુટમાં નાશ અને બદલો એ એવી જગ્યાઓ છે જેને સૌથી વધુ કાળજીપૂર્વક વાંચવી જોઈએ.
એપ્લિકેશન કાર્ય
ઉપરના "ઇન્ફ્રાસ્ટ્રક્ચર સ્કેચ જનરેટ કરો" ટેમ્પલેટનો ઉપયોગ કરીને AI પાસે એક નાનું ઇન્ફ્રાસ્ટ્રક્ચર (દા.ત. સ્ટોરેજ બકેટ અને એક્સેસ પોલિસી) જનરેટ કરવા દો. પછી: (1) કોડમાં એમ્બેડ કરેલ ગુપ્ત અથવા * પરવાનગીઓ માટે "વેટિંગ" ટેમ્પલેટ ચેક કરો; (2) જો શક્ય હોય તો, ટેસ્ટ એકાઉન્ટમાં init + plan ચલાવો અને "યોજના અર્થઘટન" નમૂના સાથે પ્લાન આઉટપુટ વાંચો; (3) કોઈપણ અનપેક્ષિત કાઢી નાખવા/ફેરફારો નોંધો.
ચેકલિસ્ટ
- [ ] મેં મારા પ્રોમ્પ્ટમાં ક્લાઉડ, ટેરાફોર્મ/પ્રદાતા સંસ્કરણ અને એન્ક્રિપ્શન/નેટવર્ક અવરોધ ઉમેર્યા છે.
- [ ] કોડમાં કોઈ સાદા લખાણ રહસ્ય નથી; ચોકસાઇ મૂલ્યો ચલ.
- [ ] મેં IAM/પરમિશનને ન્યૂનતમ પરવાનગીઓ સુધી સંકુચિત કરી છે, * મેં તેનો ઉપયોગ કર્યો નથી.
- [ ] મેં અરજી કરતા પહેલા પ્લાન ચલાવ્યો અને આઉટપુટ લાઇન બાય લાઇન વાંચી.
- [ ] મેં ચકાસ્યું કે યોજનામાં કોઈ અણધારી નાશ/ફેરબદલી નથી.
- [ ] મને ખાતરી છે કે રાજ્યને એન્ક્રિપ્ટેડ, લોક અને પ્રતિબંધિત બેકએન્ડમાં રાખવામાં આવ્યું છે.