સ્ક્રિપ્ટ અને ઓટોમેશન જનરેશન: બેશ, પાયથોન અને પાવરશેલ

નફો:

• Bash, Python અને PowerShell ની શક્તિઓને સમજવાની ક્ષમતા અને કૃત્રિમ બુદ્ધિમત્તા સુરક્ષિત, સુરક્ષિત સ્ક્રિપ્ટ ડ્રાફ્ટ બનાવે છે
• સેટ -યુઓ પાઇપફેલ, ખાલી વેરિયેબલ ચેકિંગ, ડ્રાય-રન મોડ અને લોગિંગ જેવી સ્ક્રિપ્ટ્સમાં ગાર્ડરેલ્સ ઉમેરવાની ક્ષમતા
• વિનાશક આદેશો વાંચવાની અને તેમને અલગ વાતાવરણમાં અને પહેલા ડ્રાય-રન સાથે અજમાવવાની અને સ્ક્રિપ્ટમાં રહસ્યને એમ્બેડ ન કરવાની શિસ્ત લાગુ કરવાની ક્ષમતા.

DevOps ની ભાવનાનો સારાંશ એક વાક્યમાં છે: "તમે બે વાર કરો છો તે કાર્યને સ્વચાલિત કરો." કોઈપણ પુનરાવર્તિત કાર્ય જે મેન્યુઅલી કરવામાં આવે છે - લોગ ક્લિનઅપ, બેકઅપ લેવા, સર્વર હેલ્થ ચેક, બેચ ફાઇલ પ્રોસેસિંગ - સમય લે છે અને આખરે માનવ ભૂલ દ્વારા બગડે છે. સ્ક્રિપ્ટો આ નોકરીઓ સંભાળે છે: નાના પ્રોગ્રામ્સ કે જે શ્રેણીબદ્ધ આદેશોને ક્રમિક, વિશ્વસનીય અને પુનરાવર્તિત રીતે ચલાવે છે. DevOps પ્રોફેશનલ વારંવાર ત્રણ ભાષાઓનો ઉપયોગ કરે છે: બેશ (લિનક્સ/યુનિક્સ શેલ સ્ક્રિપ્ટ્સ માટે), પાયથોન (જટિલ તર્ક માટે, API કૉલિંગ, ડેટા મેનીપ્યુલેશન માટે), અને પાવરશેલ (વિન્ડોઝ અને ક્લાઉડ મેનેજમેન્ટ માટે).

AI કદાચ તે છે જ્યાં તે સ્ક્રિપ્ટ જનરેશનમાં સૌથી વધુ વ્યવહારુ મૂલ્ય પ્રદાન કરે છે: એક-વાક્યના વર્ણનમાંથી કાર્યકારી ડ્રાફ્ટનું નિર્માણ કરવું, રહસ્યમય ભૂલને હલ કરવી, સ્ક્રિપ્ટને બીજી ભાષામાં અનુવાદિત કરવી. પરંતુ સ્ક્રિપ્ટ ખતરનાક છે જ્યારે આંખ આડા કાન કરવામાં આવે છે - એક ખોટો આરએમ, રીમૂવ-આઇટમ -રીકર્સ ફાઇલોને બદલી ન શકાય તેવી રીતે કાઢી નાખશે. તેથી જ આ એકમનું સૂત્ર છે: AI ને સ્ક્રિપ્ટ લખવા દો, તમે તેને વાંચો, તેને પહેલા સલામત મોડમાં અજમાવો, પછી તેને ચલાવો.

કઈ ભાષા પસંદ કરવી અને ક્યારે? અંગૂઠાનો ખરબચડો નિયમ: જો નોકરીમાં એક પંક્તિમાં ઘણા સિસ્ટમ આદેશો ચલાવવાનો સમાવેશ થાય છે (ફાઇલની નકલ કરો, સેવા પુનઃપ્રારંભ કરો, આર્કાઇવ પુનઃપ્રાપ્ત કરો) બાશ એ સૌથી કુદરતી પસંદગી છે કારણ કે લિનક્સ સર્વર્સ પર સર્વવ્યાપક છે. જો જોબમાં નિર્ણય તર્ક, લૂપિંગ, ડેટા ટ્રાન્સફોર્મેશન, API વિનંતી અથવા JSON પ્રોસેસિંગ-એટલે કે, 20 લાઇનથી વધુનું લોજિક-પાયથોન તેની વાંચનક્ષમતા અને સમૃદ્ધ લાઇબ્રેરીઓ માટે અલગ છે; જટિલ બાશ સ્ક્રિપ્ટ ઝડપથી અગમ્ય બની જાય છે, જ્યારે પાયથોન જાળવવા માટે સરળ રહે છે. જો નોકરીમાં વિન્ડોઝ સર્વર્સ, એક્ટિવ ડિરેક્ટરી અથવા એઝ્યુરનું સંચાલન કરવાનું સામેલ હોય, તો પાવરશેલ એ કુદરતી વાતાવરણ છે કારણ કે તેની ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રકૃતિ આ પ્લેટફોર્મ્સ સાથે ઊંડાણપૂર્વક સંકલિત થાય છે. AI ને સ્ક્રિપ્ટની વિનંતી કરતી વખતે તમે કઈ ભાષા પસંદ કરી છે અને શા માટે તે સ્પષ્ટ કરવું એ ખાતરી કરે છે કે આઉટપુટ તમારા પર્યાવરણ માટે યોગ્ય અને રૂઢિપ્રયોગાત્મક છે.

સ્ટેપ બાય સ્ટેપ: સુરક્ષિત સ્ક્રિપ્ટ જનરેશન

1. કાર્ય અને પર્યાવરણનું વર્ણન કરો. તે શું કરશે, કયા OS/શેલ, કયા અવરોધો છે?
2. સલામતી રેલિંગ માટે પૂછો. bash માં, સેટ -euo પાઇપફેલ (ભૂલ પર રોકો, અવ્યાખ્યાયિત ચલ પર રોકો), જોખમી કામગીરી માટે પુષ્ટિકરણ પ્રોમ્પ્ટ, કાઢી નાખવાને બદલે પહેલા ખસેડો.
3. ડ્રાય-રન મોડની વિનંતી કરો. સ્ક્રિપ્ટને લખવા દો કે --ડ્રાય-રન સાથે શું કરવું, પણ તે ન કરો.
4. વાંચો અને સમજો. દરેક પંક્તિ શું કરે છે તે ચકાસો, ખાસ કરીને ડિલીટ/મૂવ/નેટવર્ક ઓપરેશન્સ.
5. તેને અલગ વાતાવરણમાં અજમાવી જુઓ. પરીક્ષણ ફોલ્ડરમાં, તેને નમૂના ડેટા સાથે ચલાવો.
6. લોગીંગમાં ઉમેરો. સ્ક્રિપ્ટને રેકોર્ડ કરવા દો કે તે શું કરે છે જેથી તે પછીથી જોઈ શકાય.

સલામત સ્ક્રિપ્ટીંગની આવશ્યકતાઓ

પ્રોડક્શન સ્ક્રિપ્ટમાં આ ગાર્ડ્રેલ્સ શામેલ હોવા જોઈએ:

• ભૂલના કિસ્સામાં રોકવું. બેશ: સેટ -યુઓ પાઇપફેઇલ. પાવરશેલ: $ErrorActionPreference = 'સ્ટોપ'. જો એક પગલું નિષ્ફળ જાય, તો પછીના પગલાં કામ ન કરવા જોઈએ.
• આઇડમ્પોટેન્સી (પુનરાવર્તનક્ષમતા). જો સ્ક્રિપ્ટ બે વાર ચાલે છે, તો તેને ડબલ નુકસાન ન થવું જોઈએ; "જો તમારી પાસે પહેલેથી જ છે, તો તેને છોડો" તર્ક.
• મંજૂરી અને ડ્રાય-રન. વિનાશક કામગીરી માટે "શું તમને ખાતરી છે?" અથવા --ડ્રાય-રન ધ્વજ.
• ઇનપુટ માન્યતા. શું પરિમાણો અપેક્ષા મુજબ છે? ખાલી ચલ rm -rf "$DIR"/ ને rm -rf/ ડિઝાસ્ટરમાં ફેરવી શકે છે.
• લોગીંગ. શું અને ક્યારે કરવામાં આવ્યું તેનો રેકોર્ડ.

ટીપ: Bash માં સૌથી ખતરનાક ભૂલ એ ખાલી વેરીએબલ સાથે કાઢી નાખવાની છે. જો $DIR ખાલી હોય તો rm -rf "$DIR" રૂટ ડિરેક્ટરીને કાઢી નાખવાનો પ્રયાસ કરે છે. સેટ -u (અવ્યાખ્યાયિત ચલ પર રોકો) અને કાઢી નાખતા પહેલા [ -n "$DIR" ] તપાસવું એ જીવન બચાવનાર છે. AI થી સ્ક્રિપ્ટની વિનંતી કરતી વખતે સ્પષ્ટપણે આ સુરક્ષાની વિનંતી કરો.

સુરક્ષા: ગુપ્ત અને વિનાશક આદેશો

બે મોટા જોખમો:

1. સ્ક્રિપ્ટમાં રહસ્ય એમ્બેડ કરવું. પાસવર્ડ ટોકન સ્ક્રિપ્ટમાં સાદો લખાણ હોવો જોઈએ નહીં; પર્યાવરણ વેરીએબલ અથવા વૉલ્ટમાંથી વાંચવું આવશ્યક છે. સ્ક્રિપ્ટો ગિટમાં જાય છે; દફનાવવામાં આવેલ ગુપ્ત કાયમી લીક છે.
2. વિનાશક આદેશો. rm -rf, Remove-Item -Recurse -Force, DROP TABLE, terraform નાશ — જ્યારે તમે આને સ્ક્રિપ્ટમાં જુઓ, ત્યારે રોકો અને બે વાર વિચારો. પહેલા ઉત્પાદનમાં AI દ્વારા જનરેટ કરાયેલ વિનાશક આદેશને ક્યારેય અજમાવશો નહીં.

સાવધાન: જ્યારે તમે AI ને કહો છો કે "એક સ્ક્રિપ્ટ લખો જે આ ફાઇલોને સાફ કરે છે", ત્યારે તે બનાવેલ શોધ... -delete અથવા rm આદેશનો અવકાશ કાળજીપૂર્વક વાંચો. વાઇલ્ડકાર્ડ (*) અથવા ખોટો પાથ તમે કાઢી નાખવા માંગો છો તેના કરતાં વધુ કાઢી નાખશે. હંમેશા ડિલીટ કરવાને બદલે "લિસ્ટ ટુ ડિલીટ" મોડ સાથે પહેલા સ્ક્રિપ્ટ ચલાવો.

ત્રણ ભાષાઓની સરખામણી

માપદંડ

બેશ

અજગર

પાવરશેલ

જ્યાં તે શ્રેષ્ઠ છે

Linux શેલ, આદેશ સાંકળ

જટિલ તર્ક, API, ડેટા

વિન્ડોઝ ક્લાઉડ મેનેજમેન્ટ

શીખવાની કર્વ

મધ્યમ (ફસાયેલા)

સરળ

મધ્યમ

હેન્ડલિંગમાં ભૂલ

સેટ -યુઓ પાઇપફેલ

પ્રયાસ કરો/સિવાય

પ્રયાસ/પકડવું, -ભૂલ ક્રિયા

સુવાહ્યતા

યુનિક્સ/લિનક્સ/મેક

દરેક જગ્યાએ

ક્રોસ-પ્લેટફોર્મ (PS 7+)

જ્યારે

ટૂંકમાં, સિસ્ટમ કામ કરે છે

20 લીટીઓ કરતા લાંબો તર્ક

વિન્ડોઝ/એડી/એઝ્યુર

ત્રણ નાના કેસો

કેસ 1 - 5 મિનિટમાં 2 કલાકની હસ્તકલા. એક ઇજનેર દર અઠવાડિયે 40 સર્વરમાંથી લોગ એકત્ર કરવામાં અને આર્કાઇવ કરવામાં 2 કલાક વિતાવતો હતો. તેની પાસે AI કાર્યનું વર્ણન હતું અને -euo pipefail + ડ્રાય-રન પ્રોટેક્શન સેટ કરે છે અને Bash સ્ક્રિપ્ટ જનરેટ કરે છે. પહેલા ડ્રાય-રન સાથે સ્ક્રિપ્ટને માન્ય કરી, પછી તેને સુનિશ્ચિત કાર્ય (ક્રોન) સાથે લિંક કરી. સાપ્તાહિક કાર્ય 5 મિનિટ સુધી ઘટાડવામાં આવે છે અને માનવ ભૂલ દૂર થાય છે.

કેસ 2 - નલ વેરિયેબલ આપત્તિ ટાળી. AI દ્વારા નિર્મિત ક્લિનિંગ સ્ક્રિપ્ટમાં rm -rf "$TARGET"/* હતી, પરંતુ જો TARGET ક્યાંક અસાઇન કરવામાં આવ્યું ન હતું, તો તે ખાલી રહે છે. એન્જિનિયર તરીકે ભણતી વખતે તેને આ વાત સમજાઈ હતી; સેટ -u અને [ -n "$TARGET" ] || એક્ઝિટ 1 નિયંત્રણ ઉમેર્યું. પરીક્ષણ દરમિયાન ચલ શૂન્ય રહ્યું અને સ્ક્રિપ્ટ આપત્તિજનક થવાને બદલે સુરક્ષિત રીતે બંધ થઈ ગઈ.

કેસ 3 — એમ્બેડેડ ટોકન કેપ્ચર. અનુકૂળતા માટે, AI એ Python સ્ક્રિપ્ટમાં TOKEN = "ghp_realtoken" લાઇન ઉમેરી છે જે API (ઉદાહરણ તરીકે) ની વિનંતી કરે છે. એન્જિનિયરે આને દૂર કર્યું અને તેને os.environ["TOKEN"] વડે પર્યાવરણ વેરીએબલમાંથી રીડિંગમાં બદલ્યું અને ટોકન રદ કરીને રિન્યુ કર્યું. જો સ્ક્રિપ્ટ Git પર જશે, તો ટોકન સાર્વજનિક હશે.

ચાર નકલ કરી શકાય તેવા નમૂનાઓ

1) સુરક્ષિત બેશ સ્ક્રિપ્ટ:

બેશ સ્ક્રિપ્ટ લખો: [ટાસ્ક]. ફરજિયાત નિયમો:- શરૂઆતમાં `સેટ -euo pipefail`.- ડિલીટ/ખસેડતી વખતે વેરીએબલ ખાલી નથી તે તપાસો.- `-ડ્રાય-રન` ફ્લેગ: આ મોડમાં શું કરવું તે લખો પણ તે ન કરો.- ગુપ્તને એમ્બેડ કરશો નહીં; પર્યાવરણ ચલમાંથી વાંચો. - દરેક પગલા પર માહિતીપ્રદ લોગ છાપો. સ્ક્રિપ્ટ પર ટિપ્પણી કરો અને સૌથી ખતરનાક રેખાને ચિહ્નિત કરો.

2) સ્ક્રિપ્ટ વર્ણન/નિયંત્રણ:

નીચેની સ્ક્રિપ્ટ લાઇનનું લાઇન દ્વારા વર્ણન કરો અને સુરક્ષા માટે તપાસો: એમ્બેડેડ સિક્રેટ, ડિસ્ટ્રક્ટિવ કમાન્ડ (rm/Remove-Item/DROP), અમાન્ય ઇનપુટ, એરર હેન્ડલિંગનો અભાવ? દરેક જોખમને મહત્વ અને સુધારાના ક્રમમાં લખો. સ્ક્રિપ્ટ: [CODE]

3) ભાષા અનુવાદ:

તે [સોર્સ લેંગ્વેજ] સ્ક્રિપ્ટનો [લક્ષ્ય ભાષા]માં અનુવાદ કરો. વર્તણૂકને શબ્દશઃ રાખો, લક્ષ્ય ભાષાના રૂઢિપ્રયોગિક ભૂલ હેન્ડલિંગનો ઉપયોગ કરો, કોઈપણ એમ્બેડેડ રહસ્યોને પર્યાવરણ ચલમાં ખસેડો. નોંધ પોઈન્ટ કે જે અલગ રીતે વર્તે છે. સ્ક્રિપ્ટ: [CODE]

4) આયોજિત કાર્ય (ક્રોન/સુનિશ્ચિત કાર્ય):

આ સ્ક્રિપ્ટનો ઉપયોગ કરો [ફ્રીક્વન્સી: દા.ત. શેડ્યૂલની વ્યાખ્યા લખો ([ક્રોન / સિસ્ટમડ ટાઇમર / વિન્ડોઝ ટાસ્ક શેડ્યૂલર]) જે [દરરોજ રાત્રે 02:00 વાગ્યે] ચાલશે. નિષ્ફળતા પર મને કેવી રીતે ચેતવણી આપવી (લોગ/એક્ઝિટ કોડ/સૂચના) અને ઓવરલેપને કેવી રીતે અટકાવવું તે ઉમેરો.

નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ

નબળા: "એક સ્ક્રિપ્ટ લખો જે જૂની ફાઇલોને કાઢી નાખે છે."

પરિણામ: એક અવકાશહીન, અસુરક્ષિત, ડ્રાય-રનલેસ rm સ્ક્રિપ્ટ; જો તે ખોટા ફોલ્ડરમાં ચાલે છે, તો તે ઉલટાવી શકાય તેવું કાઢી નાખવામાં આવશે.

મજબૂત: "/var/log/app હેઠળ 30 દિવસ કરતાં જૂની .log ફાઇલોને કાઢી નાખવા માટે બેશ સ્ક્રિપ્ટ લખો. સેટ -euo પાઇપફેલનો ઉપયોગ કરો, જો લક્ષ્ય નિર્દેશિકા ખાલી હોય તો રોકો, પ્રથમ --dry-run સાથે શું કાઢી નાખવું તેની સૂચિ બનાવો, દરેક વ્યવહારને લોગ કરો, ગુપ્તને એમ્બેડ કરશો નહીં. સૌથી ખતરનાક રેખાને ચિહ્નિત કરો."

તફાવત: બીજો દાવો સંપૂર્ણ અવકાશ, સલામતી રેલ અને ડ્રાય-રન અપેક્ષા આપે છે; આઉટપુટ સુરક્ષિત રીતે ચલાવી શકાય છે.

સામાન્ય ભૂલો

• સ્ક્રિપ્ટ વાંચ્યા વિના ચલાવી રહ્યા છીએ. પંક્તિઓ કાઢી નાખો/મૂવ કરો ખાસ કરીને આપત્તિ તરફ દોરી જાય છે.
• ખાલી ચલો માટે તપાસી રહ્યા નથી. rm -rf "$X"/ સાથે રૂટ ડિરેક્ટરીને કાઢી નાખવાની ઉત્તમ આપત્તિ.
• `set -euo pipefail` / `-ErrorAction Stop` છોડો. એક પગલું આગ, સ્ક્રિપ્ટ આંખ આડા કાન ચાલુ રહે છે.
• સ્ક્રિપ્ટમાં રહસ્ય એમ્બેડ કરવું. ગિટમાં સતત લીક.
• ડ્રાય-રન વિના વિનાશક પ્રક્રિયા. પ્રથમ "મને શું કરવું તે બતાવો", પછી તે કરો.
• ઉત્પાદનમાં પ્રથમ પ્રયાસ કરી રહ્યા છીએ. એક અલગ પરીક્ષણ વાતાવરણ વિના દોડવું.

સારાંશમાં

DevOps એ ઓટોમેશનની કળા છે; પુનરાવર્તિત કાર્ય Bash, Python અને PowerShell સ્ક્રિપ્ટ્સને સોંપવામાં આવે છે. AI સ્ક્રિપ્ટનો મુસદ્દો તૈયાર કરવા, ડિબગીંગ કરવા અને ભાષાઓનું ભાષાંતર કરવા માટે ખૂબ જ સરળ છે - પરંતુ સુરક્ષિત સ્ક્રિપ્ટમાં સેટ -euo પાઇપફેલ, નલ વેરિયેબલ ચેકિંગ, ડ્રાય-રન મોડ, એમ્બેડેડ સિક્રેટલેસનેસ અને લોગિંગ જેવા એરર ગાર્ડ્સનો સમાવેશ થવો જોઈએ. દરેક સ્ક્રિપ્ટને વાંચવાની અને પરીક્ષણ કરવાની તમારી જવાબદારી છે, ખાસ કરીને જે વિનાશક આદેશો ધરાવે છે, એક અલગ વાતાવરણમાં અને પહેલા ડ્રાય-રન.

એપ્લિકેશન કાર્ય

પુનરાવર્તિત કાર્ય પસંદ કરો (લોગ આર્કાઇવિંગ, બેકઅપ, સફાઈ). (1) AI પાસે "Secure Bash સ્ક્રિપ્ટ" ટેમ્પ્લેટ સાથે સુરક્ષિત સ્ક્રિપ્ટ જનરેટ કરવા દો. (2) "સ્ક્રીપ્ટ વર્ણન/ઓડિટ" ટેમ્પલેટ તરીકે સુરક્ષા માટે સમાન સ્ક્રિપ્ટ તપાસો અને એઆઈએ ફ્લેગ કરેલી સૌથી ખતરનાક લાઇન શોધો. (3) ટેસ્ટ ફોલ્ડરમાં સેમ્પલ ફાઇલો સાથે સ્ક્રિપ્ટ ચલાવીને તેની વર્તણૂકને ચકાસો, પહેલા --dry-run સાથે.

ચેકલિસ્ટ

• [ ] મેં તે કાર્ય લખ્યું જે મને જોઈતું નથી, OS/શેલ અને સુરક્ષા રક્ષકો.
• [ ] સ્ક્રિપ્ટમાં સેટ -euo pipefail / -ErrorAction Stop જેવી ભૂલ અટકાવવામાં આવી છે.
• [ ] મેં ડિલીટ/મૂવ કરતા પહેલા ખાલી વેરીએબલ અને ઇનપુટ ચેક ઉમેર્યા છે.
• વિનાશક કામગીરી માટે --dry-run/confirmation મિકેનિઝમ છે.
• [ ] સ્ક્રિપ્ટમાં કોઈ ગુપ્ત જડિત નથી; મૂલ્યો પર્યાવરણ ચલ/કેસમાંથી આવે છે.
• [ ] મેં ડ્રાય-રન સાથે એક અલગ પરીક્ષણ વાતાવરણમાં પ્રથમ પરીક્ષણ કર્યું.