లాభాలు:
- IaC కాన్సెప్ట్ మరియు టెర్రాఫార్మ్ యొక్క వర్కింగ్ సైకిల్ (init, ప్లాన్, అప్లై, స్టేట్, మాడ్యూల్)ని అర్థం చేసుకోగల సామర్థ్యం మరియు కృత్రిమ మేధస్సు సురక్షితమైన HCL డ్రాఫ్ట్లను ఉత్పత్తి చేస్తుంది
- వర్తించే ముందు ప్రణాళికతో ప్రతి మార్పును తనిఖీ చేయగల సామర్థ్యం మరియు ఊహించని నాశనం/భర్తీ పంక్తులను పట్టుకోవడం
- కోడ్ నుండి రహస్యాలను ఉంచడం, స్థితిని సురక్షితంగా ఉంచడం మరియు IAM అనుమతులను తగ్గించడం వంటి సూత్రాలను వర్తింపజేయగల సామర్థ్యం
గతంలో, సర్వర్ను సెటప్ చేయడం అనేది క్లౌడ్ ప్యానెల్ ద్వారా క్లిక్ చేయడం: వర్చువల్ మెషీన్ను సృష్టించండి, నెట్వర్క్ను సెటప్ చేయండి, భద్రతా నియమాన్ని జోడించండి. ఈ పద్ధతి నెమ్మదిగా ఉంది, లోపం సంభవించే అవకాశం ఉంది మరియు పునరావృతం కాదు - అదే వాతావరణాన్ని రెండవసారి సెటప్ చేయడం దాదాపు అసాధ్యం. నేడు, మౌలిక సదుపాయాలు కోడ్గా నిర్వహించబడుతున్నాయి. IaC (Infrastructure as Code) అనేది మాన్యువల్గా కాకుండా టెక్స్ట్ ఫైల్లలో సర్వర్లు, నెట్వర్క్లు మరియు డేటాబేస్ల వంటి క్లౌడ్ వనరులను వివరించే విధానం. ఈ ఫైల్లు వెర్షన్ కంట్రోల్ (Git)లో ఉంటాయి; ఎవరు ఏమి, ఎప్పుడు మరియు ఏమి మార్చారో మీరు చూడవచ్చు; మీరు ఒకే ఇన్ఫ్రాస్ట్రక్చర్ని చాలాసార్లు, సరిగ్గా అదే విధంగా, ఒక కమాండ్తో సెటప్ చేయవచ్చు.
అత్యంత సాధారణ IaC సాధనం Terraform. టెర్రాఫార్మ్ మీరు HCL (HashiCorp కాన్ఫిగరేషన్ లాంగ్వేజ్ — Terraform యొక్క కాన్ఫిగరేషన్ లాంగ్వేజ్) అనే చదవగలిగే భాషలో వ్రాసే నిర్వచనాలను తీసుకుంటుంది, వాటిని క్లౌడ్ ప్రొవైడర్ (AWS, Azure, GCP) APIలోకి అనువదిస్తుంది మరియు వనరులను సృష్టిస్తుంది. AIకి HCL గురించి బాగా తెలుసు మరియు కాంప్లెక్స్ బ్లాక్లను త్వరగా ఉత్పత్తి చేస్తుంది. కానీ IaCలో, పొరపాటు యొక్క ధర ఎక్కువగా ఉంటుంది: ఒక తప్పు నిర్వచనం మొత్తం ఉత్పత్తి డేటాబేస్ను తుడిచిపెట్టగలదు. అందుకే ప్రతి మార్పును అమలు చేసే ముందు ఒక ‘ప్రణాళిక’తో చూడాలన్నది టెర్రాఫార్మ్లోని గోల్డెన్ రూల్.
టెర్రాఫార్మ్ యొక్క రన్టైమ్
టెర్రాఫార్మ్ మూడు ప్రాథమిక ఆదేశాలతో పనిచేస్తుంది - AI అవుట్పుట్ని నియంత్రించడానికి వీటిని తెలుసుకోవడం అవసరం:
- `terraform init`: ప్రాజెక్ట్ను ప్రారంభిస్తుంది, అవసరమైన ప్రొవైడర్ ప్లగిన్లను డౌన్లోడ్ చేస్తుంది.
- `టెర్రాఫార్మ్ ప్లాన్`: ప్రస్తుత పరిస్థితిని కావలసిన పరిస్థితితో పోల్చి, ఏమి జోడించాలి, ఏమి మార్చాలి, ఏమి తొలగించాలి అని చూపుతుంది. ఏదీ అమలు చేయడం లేదు. ఇది అత్యంత కీలకమైన భద్రతా దశ.
- `టెర్రాఫార్మ్ అప్లై`: వాస్తవానికి ప్లాన్ని వర్తింపజేస్తుంది, వనరులను సృష్టిస్తుంది/సవరిస్తుంది.
అదనంగా, రెండు భావనలు ముఖ్యమైనవి. రాష్ట్రం (స్టేట్ ఫైల్): ఇది టెర్రాఫార్మ్ నిర్వహించే వనరుల ప్రస్తుత స్థితిని ఉంచే ఫైల్; ఇది సాధారణంగా రిమోట్ మరియు లాక్ చేయబడిన గిడ్డంగిలో నిల్వ చేయబడుతుంది, తద్వారా ఇద్దరు వ్యక్తులు ఒకే సమయంలో దానిని మార్చలేరు లేదా నాశనం చేయలేరు. మాడ్యూల్: పునర్వినియోగ కాన్ఫిగరేషన్ ప్యాకేజీ; ఉదాహరణకు, మీరు అనేక ప్రాజెక్ట్లలో "నెట్వర్క్ని సెటప్ చేయండి" మాడ్యూల్ని ఉపయోగించవచ్చు.
చిట్కా: టెర్రాఫార్మ్ అవుట్పుట్లో అత్యంత ప్రమాదకరమైన సంకేతం ప్లాన్ అవుట్పుట్లో నాశనం లేదా -/+ (భర్తీ) లైన్లు. వనరు తొలగించబడుతుందని దీని అర్థం. మీరు ప్లాన్లో ఊహించని విధ్వంసాన్ని చూసినట్లయితే, ఎప్పుడూ వర్తించదు, ముందుగా అది ఎందుకు కనిపించిందో అర్థం చేసుకోండి.
దశల వారీగా: AIతో IaC రాయడం
- కావాల్సిన మౌలిక సదుపాయాలను స్పష్టం చేయండి. eu-central-1లో "ఒక VPC, రెండు సబ్నెట్లు, ఒక భద్రతా సమూహం మరియు ఒక t3.micro EC2" వంటి నిర్దిష్టంగా ఉండండి.
- ప్రొవైడర్ మరియు సంస్కరణను పేర్కొనండి. ఏ క్లౌడ్, ఏ టెర్రాఫార్మ్ మరియు ప్రొవైడర్ వెర్షన్? మీరు సంస్కరణను పేర్కొనకుంటే, AI కాలం చెల్లిన/అనుకూలమైన సింటాక్స్ని అందించవచ్చు.
- HCL డ్రాఫ్ట్ను రూపొందించండి. వేరియబుల్స్ మరియు అవుట్పుట్లను కూడా అభ్యర్థించండి.
- రహస్యాన్ని బయటకు తీయండి. పాస్వర్డ్లు మరియు కీలు వంటి విలువలు కోడ్కి కాకుండా వేరియబుల్ మరియు రహస్య ఖజానాకు వెళ్లాలి.
- `init` + `ప్లాన్`ని అమలు చేయండి. లైన్ ద్వారా ప్లాన్ అవుట్పుట్ను చదవండి; ఊహించని తొలగింపుల కోసం తనిఖీ చేయండి.
- చిన్నగా ప్రారంభించండి, క్రమంగా అమలు చేయండి. దీన్ని ముందుగా ఒక వివిక్త పరీక్ష ఖాతా/పర్యావరణంలో వర్తింపజేయండి.
భద్రత: IaC-నిర్దిష్ట ప్రమాదాలు
IaC ఎంత శక్తివంతమైనదో అంతే ప్రమాదకరం. మూడు క్లిష్టమైన అంశాలు:
- రాష్ట్ర ఫైలులో రహస్యం ఉంది. టెర్రాఫార్మ్ స్థితి కొన్నిసార్లు డేటాబేస్ పాస్వర్డ్ల వంటి సున్నితమైన విలువలను సాదా వచనంలో ఉంచుతుంది. రాష్ట్రాన్ని ఎప్పుడూ పబ్లిక్ రిపోజిటరీలో పెట్టవద్దు; గుప్తీకరించిన, పరిమితం చేయబడిన యాక్సెస్ రిమోట్ బ్యాకెండ్ని ఉపయోగించండి.
- హెచ్సిఎల్లో రహస్యాలను పొందుపరచవద్దు. పాస్వర్డ్="prod123" వంటి పంక్తులు Git చరిత్రకు శాశ్వతంగా వ్రాయబడతాయి. బదులుగా, వేరియబుల్ని ఉపయోగించండి మరియు ఎన్విరాన్మెంట్ వేరియబుల్ (TF_VAR_...) లేదా సీక్రెట్ వాల్ట్ నుండి రన్టైమ్లో విలువను ఇవ్వండి.
- చాలా విస్తృత IAM అనుమతి. AI కొన్నిసార్లు యాక్షన్ వంటి బ్లాక్లను ఉత్పత్తి చేస్తుంది: "*" (ప్రతిదీ అనుమతించు) "ఇది పని చేయడానికి". ఇది ఒక దుర్బలత్వం; అవసరమైన కనీస అనుమతిని తగ్గించండి.
శ్రద్ధ: ఒక రహస్యం Git చరిత్రలోకి ప్రవేశించిన తర్వాత, అది గతంలోనే ఉంటుంది మరియు మీరు ఫైల్ను తొలగించినప్పటికీ, రాజీపడవచ్చు. మీరు పొరపాటున కట్టుబడి ఉంటే, వెంటనే రద్దు చేసి రహస్యాన్ని తిప్పండి; కేవలం తొలగిస్తే సరిపోదు.
ప్రమాదకర ప్రణాళిక సంకేతాల పట్టిక
ప్రింట్అవుట్ని ప్లాన్ చేయండి
అర్థం
ఏమి చేయాలి
+సృష్టించు
కొత్త వనరు జోడించబడుతుంది
సాధారణంగా సురక్షితం, అయితే సమీక్షించండి
~ స్థానంలో నవీకరణ
సైట్లో మూలం మారుతుంది
ప్రభావాన్ని ధృవీకరించండి (అంతరాయం ఏర్పడుతుందా?)
-/+ భర్తీ చేయండి
తొలగించబడుతుంది మరియు మళ్లీ సృష్టించబడుతుంది
జాగ్రత్త: డేటా నష్టం సంభవించవచ్చు
- నాశనం
వనరు నాశనం అవుతుంది
ఆపు: మీరు ఆశించనట్లయితే ఎప్పుడూ వర్తించవద్దు
మూడు చిన్న కేసులు
కేసు 1 — 3 గంటల్లో 2 రోజుల పని. ఒక బృందం కొత్త పరీక్ష వాతావరణాన్ని (VPC, సబ్నెట్లు, RDS డేటాబేస్, ECS క్లస్టర్) సెటప్ చేయడానికి టెర్రాఫార్మ్ను వ్రాయబోతోంది, కానీ వారు ఇప్పుడే HCLకి మారారు. వారు ఆర్కిటెక్చర్ మరియు సంస్కరణలను AIకి వివరించారు మరియు మాడ్యులర్ బ్లూప్రింట్ను రూపొందించారు. వారు ప్లాన్తో ప్రతి మాడ్యూల్ను ధృవీకరించారు మరియు దానిని 3 గంటల్లో అమలు చేసారు; ఇది వారికి రెండు రోజుల మాన్యువల్ ట్రయల్ మరియు ఎర్రర్ పడుతుంది.
కేస్ 2 - ప్లాన్ తొలగించబడింది. AI రూపొందించిన అప్డేట్ కోడ్ని వర్తింపజేయకుండానే ఒక ఇంజనీర్ ప్లాన్ని అమలు చేశాడు. ఉత్పత్తి డేటాబేస్ కోసం భర్తీ -/+ కలిగి ఉన్న అవుట్పుట్ — AI రీప్లేస్ చేయలేని ఫీల్డ్ను భర్తీ చేయడానికి ప్రయత్నించింది, దీని అర్థం డేటాబేస్ను తొలగించడం మరియు మళ్లీ సృష్టించడం. ఇంజనీర్ దరఖాస్తును ఆపివేసి, సురక్షిత పద్ధతికి మార్చారు. ప్రణాళికాబద్ధమైన అలవాటు విపత్తును నిరోధించింది.
కేసు 3 - ఖననం చేయబడిన రహస్య లీక్. ఒక జూనియర్, YZ జారీ చేసిన db_password = "S3cret!" లైన్ని యథాతథంగా కమిట్ చేసి నెట్టేశాడు. కోడ్ సమీక్షలో చిక్కుకున్నారు; పాస్వర్డ్ వెంటనే రద్దు చేయబడింది మరియు మార్చబడింది, విలువ వేరియబుల్కు తరలించబడింది మరియు రహస్య ఖజానా నుండి అందించబడింది. పాఠం: HCLలో ఎప్పుడూ సాదాసీదా రహస్యాలు ఉండవు.
నాలుగు కాపీ చేయగల టెంప్లేట్లు
1) మౌలిక సదుపాయాల ముసాయిదాను రూపొందించడం:
టెర్రాఫార్మ్ (వెర్షన్ ~> 1.7)తో [CLOUD: AWS]పై కింది మౌలిక సదుపాయాలను వ్రాయండి: [SOURCE LIST]. ప్రాంతం [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 అవస్థాపనను పునరావృత, సంస్కరణ మరియు ఆడిట్ చేయదగిన కోడ్గా మారుస్తుంది; అత్యంత సాధారణ సాధనం Terraform. AI త్వరగా HCL స్టబ్లను ఉత్పత్తి చేస్తుంది, కానీ మీరు తప్పనిసరిగా వెర్షన్, క్లౌడ్-నిర్దిష్ట వివరాలు మరియు భద్రతా నియమాలను అందించాలి. టెర్రాఫార్మ్లో తప్పుపట్టలేని నియమం: ప్రతి మార్పును ప్లాన్తో చూడటం, ఊహించని తొలగింపులను ప్రశ్నించడం, రహస్యాలను కోడ్కు దూరంగా ఉంచడం మరియు రాష్ట్రాన్ని సురక్షితంగా ఉంచడం. ప్లాన్ అవుట్పుట్లోని పంక్తులను నాశనం చేయడం మరియు భర్తీ చేయడం చాలా జాగ్రత్తగా చదవవలసిన ప్రదేశాలు.
అప్లికేషన్ టాస్క్
పైన ఉన్న "ఇన్ఫ్రాస్ట్రక్చర్ స్కెచ్ని రూపొందించు" టెంప్లేట్ని ఉపయోగించి AI ఒక చిన్న మౌలిక సదుపాయాలను (ఉదా. నిల్వ బకెట్ మరియు యాక్సెస్ పాలసీ) రూపొందించేలా చేయండి. అప్పుడు: (1) కోడ్లో పొందుపరిచిన రహస్య లేదా * అనుమతుల కోసం "వెట్టింగ్" టెంప్లేట్ తనిఖీని కలిగి ఉండండి; (2) వీలైతే, పరీక్ష ఖాతాలో init + ప్లాన్ని అమలు చేయండి మరియు "ప్లాన్ ఇంటర్ప్రెటేషన్" టెంప్లేట్తో ప్లాన్ అవుట్పుట్ను చదవండి; (3) ఏదైనా ఊహించని తొలగింపులు/మార్పులను గమనించండి.
చెక్లిస్ట్
- [ ] నేను నా ప్రాంప్ట్కు క్లౌడ్, టెర్రాఫార్మ్/ప్రొవైడర్ వెర్షన్ మరియు ఎన్క్రిప్షన్/నెట్వర్క్ పరిమితులను జోడించాను.
- [ ] కోడ్లో సాదా వచన రహస్యం లేదు; ఖచ్చితమైన విలువలు వేరియబుల్.
- [ ] నేను IAM/అనుమతులను కనిష్ట అనుమతులకు కుదించాను, * నేను దానిని ఉపయోగించలేదు.
- [ ] నేను వర్తించే ముందు ప్లాన్ని అమలు చేసాను మరియు అవుట్పుట్ లైన్ను లైన్ వారీగా చదివాను.
- [ ] ప్లాన్లో ఊహించని విధ్వంసం/భర్తీ ఏమీ లేదని నేను ధృవీకరించాను.
- [ ] రాష్ట్రం ఎన్క్రిప్ట్ చేయబడిన, లాక్ చేయబడిన మరియు పరిమితం చేయబడిన బ్యాకెండ్లో ఉంచబడిందని నేను ఖచ్చితంగా అనుకుంటున్నాను.