Pamamahala ng Infrastructure bilang Code (IaC): Terraform, Ansible at Plan Control

Mga nadagdag:

• Kakayahang gumawa ng IaC (Terraform, Ansible) na code na may artificial intelligence na may pinakamaliit na pahintulot at ligtas na mga default at maunawaan ang deklaratibong diskarte
• Kakayahang maiwasan ang pagkawala ng data sa pamamagitan ng pagbabasa at pagkuha ng mga tanggalin at puwersahang pagpapalit ng mga linya bago ilapat ang plano/suriin ang output
• Kakayahang maiwasan ang lihim na pagtagas sa pamamagitan ng pagpapanatiling naka-encrypt, naka-lock, sa remote na backend ang file ng estado at hatiin ang mga pagbabago sa maliliit, nababaligtad na mga hakbang

Pamamahala ng Infrastructure bilang Code (IaC): Terraform, Ansible at Plan Control na may AI

Noong nakaraan, ang pagse-set up ng isang server ay ginawa gamit ang mga manu-manong pag-click, utos, at mga personal na tala; Ang resulta ay hindi na maibabalik na "snowflake" na mga server na walang nakakaalam nang eksakto kung paano i-set up. Ang Infrastructure as Code (IaC) ay ang diskarte na nagtatapos sa kaguluhang ito: ang mga server, network, mga panuntunan sa seguridad ay tinukoy hindi sa pamamagitan ng kamay, ngunit sa pamamagitan ng mga nababagong text file (code). Kapag pinatakbo mo ang code na ito, ise-set up ang imprastraktura nang eksakto tulad ng isinulat mo nito — pareho, nakadokumento, at nauulit sa bawat oras. Ang pinakakaraniwang tool ay Terraform at CloudFormation para sa cloud infrastructure at Ansible para sa configuration ng server. Dito ang AI ay napakahusay sa pagsulat, pagpapaliwanag at pagrepaso sa IaC code na ito. Ngunit ang kapangyarihan ng IaC ay ang panganib din nito: ang isang maling linya ay maaaring puksain ang isang buong imprastraktura; kaya ang AI ay nagsusulat ng code, binasa mo ang "plano", aprubahan ito at isagawa ito.

Sa yunit na ito, tatalakayin natin ang declarative approach, ang plan/apply distinction, state security at idempotency; Matututuhan mo ang pagbuo ng IaC na may AI at ang pinaka-kritikal na kasanayan, "kontrol sa plano".

Pag-iisip nang deklaratibo: "paano kung", hindi "paano gagawin"

Karamihan sa mga tool ng IaC ay deklaratibo: inilalarawan mo ang huling estado ng system ("sabihin nating 3 web server, 1 load balancer"), ang tool mismo ay kinakalkula kung paano makarating sa estado na iyon. Ito ay iba sa pagsulat ng isang script ("gawin ito, pagkatapos ay gawin iyon" hakbang-hakbang). Ang malaking bentahe ng deklaratibong diskarte ay idempotency: kahit na patakbuhin mo ang code ng sampung beses, pareho ang resulta, dahil sinusuri ng tool kung mayroon na ang nais na estado, at kung nangyari ito, hindi nito hinawakan ito. Tandaan ang pagkakaibang ito kapag sumulat ka ng IaC sa AI: gagawin mong "hayaan ang estado ng imprastraktura na ito", hindi "patakbuhin ang mga utos na ito".

Magplano/mag-apply: pinakamahalagang rehas para sa kaligtasan

Ang tampok na nagliligtas-buhay ng IaC ay ang hakbang sa plano. Sa Terraform, ang terraform plan, sa Ansible, --check mode ay gumagawa ng preview ng "ano ang magbabago kung ilalapat ko ito" bago patakbuhin ang code: "2 mapagkukunan ay idaragdag, 1 ay magbabago, 0 ay tatanggalin". Ito ang tanging paraan upang ihambing ang iyong intensyon sa katotohanan bago ang pagpapatupad. Kritikal na panuntunan: huwag mag-apply nang hindi binabasa ang plano. Hanapin lalo na para sa "sirain" linya; Kung makikita mo ang "12 ay tatanggalin" sa halip na "1 ay babaguhin" dahil sa isang typo, ang plano ay nagligtas sa iyo mula sa sakuna. Pagkatapos i-print ang code sa AI, sabihing "suriin ang linya ng output ng plano sa bawat linya kasama ko, markahan ang bawat linya na naglalaman ng pagtanggal/libangan."

Babala: Ang ilang mga pagbabago sa Terraform ay "sirain at muling likhain" ang isang mapagkukunan sa halip na "pag-update sa lugar." Nangangahulugan ito ng pagkawala ng data para sa isang database. Ang pagbalewala sa -/+ o "forces replacement" sa output ng plano ay isa sa mga pinakamahal na pagkakamali.

State file: talaan ng mga lihim at katotohanan

Ang mga tool tulad ng Terraform ay nagpapanatili sa kasalukuyang estado ng imprastraktura na kanilang pinamamahalaan sa isang file ng estado. Ang file na ito ay kritikal para sa dalawang dahilan. Una, maaaring naglalaman ito ng mga lihim (mga password sa database, ang mga key ay maaaring mahulog sa estado sa plaintext); Samakatuwid, huwag na huwag i-paste ang estado sa isang pampublikong repositoryo o AI, itago ito sa isang naka-encrypt at pinaghihigpitang access na remote na backend. Pangalawa, kung ang estado ay nasira o nawala, ang sasakyan ay nawawala ang ugnayan sa pagitan ng tunay na imprastraktura at ng naisip na imprastraktura; Samakatuwid, ang isang backup ng estado at isang mekanismo ng lock (lock na pumipigil sa dalawang tao na sirain ito nang sabay) ay mahalaga.

Hakbang-hakbang: I-secure ang IaC gamit ang AI

1. Layunin at tagapagbigay ng estado. “2 server sa AWS, na may Terraform, sa rehiyong ito, ganitong laki, at isang grupo ng seguridad.” Kung ang cloud, tool, at bersyon ay malinaw, ang AI ay gumagawa ng tamang syntax.
2. Humiling ng mga default na seguridad. "Buksan ang grupo ng seguridad, paganahin ang pag-encrypt, i-extract ang mga lihim sa variable, bigyan ng pampublikong access." Maaaring bumuo ang AI ng mga maluwag na sample bilang default.
3. Basahin at unawain ang code. Unawain ang bawat mapagkukunan, bawat pahintulot, bawat linya. Huwag maglapat ng pahintulot na hindi mo naiintindihan.
4. Kumuha ng plano at i-audit ito. Patakbuhin ang plano/--suriin, suriin ang output gamit ang AI, markahan ang tanggalin at muling itayo ang mga linya.
5. Ilapat ang maliit at nababaligtad. Magpatupad ng malaking pagbabago sa maliliit na piraso, hindi sabay-sabay. Alamin ang daan pabalik sa bawat hakbang.
6. Protektahan ang Estado. Gumamit ng remote, naka-encrypt na backend at lock; Huwag kailanman tumagas ang estado.

tatlong mini case

Kaso 1 — Nabawi ng plano ang isang database. Nais ng isang engineer na palakihin ang laki ng isang database gamit ang Terraform code na ginawa niya gamit ang AI. Habang inaasahan niyang "magbabago ang 1" sa output ng terraform plan, nakita niya ang "1 to destroy, 1 to add" — ang parameter na pinili niya ay nagti-trigger ng muling pagtatayo, hindi isang in-place na update, ibig sabihin, ang lahat ng data ay tatanggalin. Ang kontrol ng plano ay huminto sa hindi maibabalik na pagkawala ng data bago ito ipinatupad.

Case 2 — Bumalik mula sa maluwag na default. Humingi ng firewall code ang isang team sa AI. Upang patakbuhin ang halimbawa, nakabuo ang AI ng isang simpleng panuntunan na 0.0.0.0/0, ibig sabihin ay "pampubliko sa internet". Napansin ito ng engineer habang binabasa ang code at pinaliit ang access sa hanay lamang ng IP ng enterprise. Kung ito ay ipinatupad nang hindi sinusuri, ang database ay magiging bukas sa buong internet.

Kaso 3 — Napigilan ang pagtagas ng estado. Ipe-paste na sana ng isang junior member ang terraform.tfstate file sa isang pampublikong tool upang malutas ang isang isyu sa Terraform. Huminto ang senior engineer: ang estado ay naglalaman ng isang plaintext database password. Sa halip, ibinahagi ang isang naka-decrypt na buod na naglalarawan sa problema at inilipat ang estado sa remote na naka-encrypt na backend.

Apat na maaaring kopyahin na mga template

1) Pagbuo ng mapagkukunan ng IaC (secure na default):

Ang iyong tungkulin: senior cloud infrastructure engineer. [Ulap, hal. AWS] para sa [tool, hal. Terraform] bumuo ng code. Layunin: [purpose].Mga panuntunan sa seguridad: pampubliko (0.0.0.0/0) access OPEN;magsimula sa pinakamaliit na pahintulot; i-on ang pag-encrypt; kunin ang mga lihim sa mga variable, huwag i-embed ang mga ito sa code; Suriin ang mga setting na maaaring humantong sa pagtanggal/paglibang. Ipaliwanag ang bawat pinagmulan na may maikling komento.

2) Magplano ng pag-audit ng output:

Nasa ibaba ang output ng [Terraform plan / Ansible check]. Sabihin sa akin: (1) kung gaano karaming mga mapagkukunan ang idaragdag/papalitan/ tatanggalin, (2) markahan din ang mga linyang "sirain" o "puwersang palitan" na nagdudulot ng panganib ng pagkawala ng data, (3) ilista ang anumang mga pagbabago na tila hindi inaasahan o mapanganib. Output: [plano]

3) Pagsusuri sa seguridad ng IaC code:

Suriin ang sumusunod na IaC code para sa seguridad: (1) mayroon bang masyadong malawak na pag-access/mga pahintulot, (2) naka-off ba ang pag-encrypt, (3) may mga lihim ba na naka-embed sa code, (4) mayroon bang magagamit na mga mapagkukunan sa publiko? Magmungkahi ng pagwawasto para sa bawat paghahanap. Code: [masked code]

4) Hatiin ang pagbabago sa mga ligtas na bahagi:

Hindi ko gustong ipatupad itong malaking pagbabago sa imprastraktura [paliwanag] nang sabay-sabay. Hatiin ito sa maliliit, independiyenteng mga hakbang na madaling balikan. Para sa bawat hakbang: anong mga pagbabago, ano ang dapat kong bigyang pansin sa plano, paano ko ito aalisin kung may mga problema?

Mahinang prompt / Malakas na prompt

Mahinang prompt:

Sumulat ng Terraform code na lumilikha ng isang server sa AWS.

Hindi malinaw ang rehiyon, laki, seguridad, network, pag-encrypt. Gumagawa ang AI ng pinakamaluwag, pinaka tahasang mga default na gumana — kung ilalagay sa produksyon, ito ay isang kahinaan.

Napakahusay na prompt:

Ang iyong tungkulin: senior cloud infrastructure engineer. Tukuyin ang isang web server na may Terraform sa AWS eu-central-1: t3.small, mula lamang sa corporate IP range (ibibigay ko ito nang may variable), bukas ang port 443, naka-encrypt ang disk, walang pampublikong access, mandatory ang mga label. Ang mga lihim ay nabubunyag sa variable. Pagkatapos ng code: Bago ito ipatupad, sabihin sa akin ang 3 uri ng linya na dapat kong bigyang pansin sa plano at ipaliwanag ang landas ng pagbabalik.

entablado

Panganib

rehas na pangkaligtasan

pagsulat ng code

Maluwag na default (pampubliko)

Pinakamakitid na pahintulot + basahin

plano/suriin

Tinatanggal nang hindi namamalayan

Magplano ng inspeksyon, sirain ang pagmamarka

Mag-apply

Malaking isang beses na pagbabago

Maliit, nababaligtad na mga hakbang

pangangasiwa ng estado

Glaze leakage, pagbaluktot

Malayong naka-encrypt na backend + lock

Mga karaniwang pagkakamali

• Nag-aaplay nang hindi binabasa ang plano. Ang plano ay naglalarawan ng pagtanggal at muling pagtatayo; Kung ito ay nilaktawan, ang pagkawala ng data ay hindi maiiwasan.
• Hindi napapansin ang maluwag na default. Ang mga instance ng AI ay madalas na gumagawa ng 0.0.0.0/0; Kung ililipat ito sa produksyon, ibig sabihin ay open source sa buong internet.
• Leaking State. Ang pag-export ng state file sa AI ​​o open repository ay naglalantad ng mga lihim ng plaintext.
• Pag-embed ng mga lihim sa code. Ang pagsulat ng password sa IaC code ay isang patuloy na pagtagas sa kasaysayan ng bersyon ng code.
• Napagkakamalang isang muling pagtatayo para sa isang update. Ang pagwawalang-bahala sa linya ng pagpapalit ng pwersa ay magreresulta sa pagkawala ng data sa mga database.

Tip: Kahit na ibigay ang output ng plano sa isang AI upang suriin, ibabatay ang panghuling desisyon sa iyong sariling kaalaman, hindi sa text ng plano. Binubuod ng AI ang plano at nagba-flag ng mga peligrosong linya; ngunit ang sagot sa tanong na "katanggap-tanggap ba ang pagtanggal na ito" ay depende sa konteksto ng iyong negosyo.

Sa buod

Ang IaC ay nagdadala ng repeatability at dokumentasyon sa pamamagitan ng pamamahala ng imprastraktura gamit ang versionable code sa halip na mga manual na pag-click. Ang AI ay isang makapangyarihang kasosyo sa pagsulat ng code na ito, inilalarawan ito, at sinusuri ito para sa seguridad. Ngunit ang kapangyarihan ng IaC ay ang panganib nito: maaaring lipulin ng isang linya ang buong imprastraktura. Mag-isip ng deklaratibo, magsimula sa pinakamaliit na pahintulot, ayusin ang mga maluwag na default, panatilihing wala sa code at estado ang mga lihim. Ang pinakamahalagang guardrail ay ang plan/check step: huwag na huwag mag-execute nang hindi binabasa ang delete and rebuild lines. Panatilihing naka-encrypt, naka-lock, at malayuan ang Estado. Ang code ay kay AI, ang desisyon ay sa iyo.

Gawain ng aplikasyon

Pumili ng maliit na target na imprastraktura (halimbawa, isang virtual machine at isang panuntunan sa seguridad). Gamit ang template na "IaC resource generation" sa itaas, humingi sa AI ng isang code na may mga ligtas na default. I-double check ang code gamit ang template na "Pagsusuri sa seguridad ng code ng IaC" at subukang maghanap ng kahit isang maluwag na setting. Kung maaari, magpatakbo ng plan/--check sa isang test account at suriin ang output gamit ang template na "Plan output check"; Tingnan kung may delete o recreate na linya. Isulat ang iyong mga natuklasan at kung paano mo mase-secure ang estado sa 6 na puntos.

checklist

• [ ] Tinukoy ko ba ang cloud, tool at bersyon sa AI at humiling ng code na may pinakamaliit na pahintulot?
• [ ] Nasuri ko ba ang code para sa mga maluwag na default (0.0.0.0/0, closed encryption)?
• [ ] Nakuha ko na ba ang mga lihim sa variable sa halip na i-embed ang mga ito sa code?
• [ ] Nabasa ko ba ang plano/suriin ang output at minarkahan ang mga linyang tanggalin bago mag-apply?
• [ ] Nasuri ko na ba ang epekto ng pagkawala ng data ng "pagpapalit ng pwersa" / muling pagtatayo ng mga linya?
• Hindi ko ba pinananatiling naka-encrypt, naka-lock, sa remote na backend ang [ ] State file at na-leak ito?