નફો:
- DevOps શૃંખલા (પાઈપલાઈન, રૂપરેખાંકન, સ્ક્રિપ્ટ, લોગ) માં આર્ટિફિશિયલ ઈન્ટેલિજન્સ ક્યાં વાસ્તવિક સમય બચાવે છે અને જ્યાં ઉત્પાદનને અસર કરતા નિર્ણયો કાર્ય જોખમ સ્તરના આધારે માનવો પર છોડવામાં આવે છે તે પારખવામાં સક્ષમ થવાથી.
- એવી શિસ્ત લાગુ કરવાની ક્ષમતા કે જે દરેક AI આઉટપુટને સ્ત્રોત સાથે કનેક્ટ કરવા, તેને ડ્રાય ચલાવવા અને સિસ્ટમ ફિલ્ટરમાંથી પસાર કરવાના પગલાઓ દ્વારા ચકાસે છે.
- વિનંતીઓ પર ક્યારેય રહસ્યો પેસ્ટ ન કરવાની, તેને માસ્ક કરવાની અને માત્ર અધિકૃત સિસ્ટમ્સ પર જ રક્ષણાત્મક હેતુઓ માટે કામ કરવાની આદત મેળવવાની ક્ષમતા.
એક રાત્રે 03:14 વાગ્યે તમારો ફોન વાગે છે: ચુકવણી સેવા બંધ છે, પૈસા અને પ્રતિષ્ઠા દર મિનિટે ખોવાઈ રહી છે. બીજા દિવસે, એક ખોટો આદેશ હજારો સર્વરને રીબૂટ કરે છે. આ DevOps પ્રોફેશનલની દુનિયા છે - જ્યાં સુધી તે ગ્રાહકના હાથમાં ન પહોંચે ત્યાં સુધી કોડ રિપોઝીટરી (જ્યાં સૉફ્ટવેરનો સ્રોત સંગ્રહિત છે)માંથી પસાર થતા તમામ પાઇપલાઇન્સ, ઑટોમેશન અને ઑન-કોલ માટેની જવાબદારી. DevOps એ "વિકાસ" અને "ઓપરેશન્સ" શબ્દોનું સંયોજન છે: તે એક સંસ્કૃતિ અને પ્રથાઓનો સમૂહ છે જે સોફ્ટવેર ડેવલપમેન્ટ લાવે છે અને તેને એક ઝડપી, વિશ્વસનીય પ્રવાહમાં ચલાવે છે. આ પ્રવાહનું દરેક પગલું આદેશ, રૂપરેખાંકન ફાઇલ, સ્ક્રિપ્ટ ઉત્પન્ન કરે છે. આર્ટિફિશિયલ ઇન્ટેલિજન્સ (AI - સોફ્ટવેર જે ઐતિહાસિક ડેટામાંથી પેટર્ન કાઢે છે અને ટેક્સ્ટ, કોડ અને અનુમાનો ઉત્પન્ન કરે છે) ટેક્સ્ટની આ વિપુલતામાં તમારો ઘણો સમય બચાવે છે.
પરંતુ આ મોડ્યુલની શરૂઆત સ્પષ્ટ છે: AI એ સહાયક, ડ્રાફ્ટ જનરેટર અને નિર્ણય સહાયક સાધન છે; જીવંત વાતાવરણ (ઉત્પાદન, વાસ્તવિક ગ્રાહકો દ્વારા ઉપયોગમાં લેવાતી સિસ્ટમ), મધ્યરાત્રિમાં ક્યારે અને કયું બટન દબાવવું તે નક્કી કરવા માટે તમે જ જવાબદાર છો. DevOps માં, બગની કિંમત મિનિટો નથી, પરંતુ ડાઉનટાઇમ, ડેટા નુકશાન અને સુરક્ષા ભંગ છે. તેથી જ આ પ્રથમ એકમમાં આપણે શિસ્ત પર ધ્યાન કેન્દ્રિત કરીશું, સાધન પર નહીં.
DevOps ચેઇનમાં AI ક્યાં કામમાં આવે છે?
ચાલો DevOps જોબ્સને બે મોટા ક્લસ્ટરમાં વિભાજીત કરીએ. પ્રથમ ક્લસ્ટર: પુનરાવર્તિત, ટેક્સ્ટ અને સ્ટ્રક્ચરિંગ જોબ્સ. CI/CD લખવું (સતત એકીકરણ / સતત ડિલિવરી — પાઇપલાઇન જે આપમેળે કોડનું પરીક્ષણ કરે છે અને રિલીઝ કરે છે) વર્ણન, ડોકરફાઇલ (રેસીપી ફાઇલ કે જે એપ્લિકેશનને કન્ટેનરમાં પેકેજ કરે છે), જટિલ ટેરાફોર્મ (ટૂલ કે જે કોડ તરીકે ઇન્ફ્રાસ્ટ્રક્ચરને વ્યાખ્યાયિત કરે છે) બ્લોક સમજાવે છે, એક લોગનો સારાંશ આપે છે અને સિસ્ટમને રેકોર્ડિંગ સ્ટેક દ્વારા રેકોર્ડ કરે છે. બેશ સ્ક્રિપ્ટનો મુસદ્દો તૈયાર કરી રહ્યા છીએ. આ કાર્યોમાં, AI મિનિટથી સેકંડ સુધી ઘટાડે છે અને થાકતો નથી.
બીજું ક્લસ્ટર: એવા નિર્ણયો જે વિક્ષેપ, પૈસા અથવા સલામતીમાં પરિણમે છે. રીલીઝ પ્રોડ પર જશે કે કેમ, મધ્યરાત્રિએ કઈ સેવા ફરી શરૂ કરવામાં આવશે, ગુપ્ત કેવી રીતે સંગ્રહિત કરવી, ખર્ચમાં ઘટાડો કરીને કયા સંસાધનને બંધ કરવામાં આવશે. આ નિર્ણયોને સંદર્ભ, સિસ્ટમ જ્ઞાન અને જવાબદારીની જરૂર છે. અહીં, AI વિકલ્પો અને જોખમોને દૃશ્યમાન બનાવે છે - પરંતુ તમે "લાગુ કરો" બટન દબાવો.
ચાલો એક વાક્યમાં તફાવત સ્પષ્ટ કરીએ: AI "આ રૂપરેખાંકન શું કરે છે અને તેને કેવી રીતે લખવું" પ્રશ્નો પર મજબૂત છે; "શું મારે આ પ્રોડક્ટ પર લાગુ કરવું જોઈએ અને તેની ખાતરી કોણ આપશે?" જેવા પ્રશ્નો આવે ત્યારે નિર્ણય તમારો છે.
ટીપ: AI ને નોકરી આઉટસોર્સ કરતા પહેલા, પૂછો: "જો આ આઉટપુટ ખોટું હોય તો મારે શું ગુમાવવું?" જો જવાબ "થોડી મિનિટો" હોય, તો નિઃસંકોચ પ્રતિનિધિત્વ કરો. જો જવાબ "પ્રોડક્શન આઉટેજ, ડેટા લોસ અથવા લીક" છે, તો AI ને ડ્રાફ્ટ બનાવવા દો અને તમે નિર્ણય અને અમલીકરણની ચકાસણી કરો.
સ્ટેપ બાય સ્ટેપ: AI સંચાલિત DevOps બિઝનેસ કેવી રીતે કામ કરે છે?
- સંદર્ભ એકત્રિત કરો. કયા ક્લાઉડ (AWS, Azure, GCP), કયા ટૂલ વર્ઝન, કયા અવરોધો? જો તમે AIને અપૂર્ણ સંદર્ભ આપો છો, તો તમને અધૂરું અને જોખમી આઉટપુટ મળશે.
- સ્પષ્ટ કાર્યો વ્યાખ્યાયિત કરો. "પાઈપલાઈન લખો" નહીં; કહો, "GitHub ક્રિયાઓ સાથે, મુખ્ય શાખામાં એક વર્કફ્લો લખો જે પુશ પર ચાલે છે, પરીક્ષણો ચલાવે છે, ડોકર ઇમેજ બનાવે છે, પરંતુ તેને જમાવતું નથી."
- ડ્રાફ્ટ તૈયાર કરો. AI ને પ્રથમ સંસ્કરણ લખવા દો.
- ચકાસો. વાક્યરચના તપાસો, ગોપનીય માહિતી લીક થઈ છે કે કેમ તે જુઓ, ડ્રાય-રન સાથે પરીક્ષણ કરો (એક મોડ જે ખરેખર એપ્લિકેશનને શું કરવું તે બતાવે છે).
- તેને સેન્ડબોક્સમાં અજમાવી જુઓ. ઉત્પાદનમાં પ્રથમ પ્રયાસ ક્યારેય કરશો નહીં; પરીક્ષણ/સ્ટેજિંગ વાતાવરણમાં ચલાવો.
- ધીમે ધીમે લાગુ કરો અને મોનિટર કરો. મેટ્રિક્સ અને લૉગ્સનું નિરીક્ષણ કરીને તેને લાઇવ મેળવો.
ચકાસણી શિસ્ત: ત્રણ પગલાં
AI અસ્ખલિત અને વિશ્વાસપૂર્વક બોલે છે; તેનો અર્થ એ નથી કે તે સાચું છે. AI ક્યારેક-ક્યારેક આભાસ પેદા કરે છે - જે અસ્તિત્વમાં નથી તેવા કમાન્ડ ફ્લેગ, ક્લાઉડ સર્વિસનું નામ અથવા રૂપરેખાંકન કી વાસ્તવિક તરીકે બનાવે છે. DevOps માં, બોગસ --force ફ્લેગ ડેટાને કાઢી શકે છે, જ્યારે બોગસ IAM (ઓળખ અને ઍક્સેસ મેનેજમેન્ટ) પરવાનગી સુરક્ષા નબળાઈ બનાવે છે. પ્રતિબિંબ:
- તેને સ્ત્રોત સાથે જોડો. શું એઆઈ દ્વારા આપવામાં આવેલ દરેક આદેશ અને ધ્વજ ખરેખર સત્તાવાર દસ્તાવેજોમાં છે? "મને કહો કે આ ધ્વજ કયા સંસ્કરણમાં આવે છે અને તેનું નામ સત્તાવાર દસ્તાવેજમાં છે"; જો ખાતરી ન હોય, તો તેના પર વિશ્વાસ કરશો નહીં.
- શુષ્ક ચલાવો. ટેરાફોર્મ પ્લાન, kubectl --dry-run, --check જેવા મોડ્સ સાથે વાસ્તવમાં તેને લાગુ કર્યા વિના શું થાય છે તે જુઓ.
- તેને સિસ્ટમ ફિલ્ટરમાંથી પસાર કરો. શું આઉટપુટ તમારા આર્કિટેક્ચર, સુરક્ષા નીતિ અને ઉપલબ્ધ સંસાધન નામો સાથે મેળ ખાય છે? તમારું ડોમેન જ્ઞાન અંતિમ ફિલ્ટર છે.
ધ્યાન આપો: "એઆઈએ આવું લખ્યું છે" એ વાજબીપણું નથી. પ્રોડ વિક્ષેપના કિસ્સામાં, જવાબદારી એઆઈની નથી, પરંતુ તે વ્યક્તિની છે જે તે આદેશને ચકાસ્યા વિના ચલાવે છે. વણચકાસાયેલ AI આદેશ એ rm -rf વાંચ્યા વિના ચલાવવામાં આવે તેટલો જ જોખમી છે.
સુરક્ષા અને રહસ્યો: ક્યારેય લીક નહીં
DevOps માં સૌથી મહત્વપૂર્ણ ગોપનીયતા નિયમ રહસ્યો વિશે છે. ગુપ્ત; તે પાસવર્ડ, API કી, ડેટાબેઝ કનેક્શન સ્ટ્રિંગ, ખાનગી પ્રમાણપત્ર જેવી ગોપનીય માહિતી છે, જે તમારી આખી સિસ્ટમ ખોલી શકે છે જો તેની સાથે ચેડા કરવામાં આવે તો. AI પ્રોમ્પ્ટમાં કોઈપણ વાસ્તવિક રહસ્યો પેસ્ટ કરશો નહીં. જો કોડના બ્લોકમાં વાસ્તવિક AWS એક્સેસ કી, .env ફાઇલની સામગ્રી અથવા પ્રોડક્શન ડેટાબેઝ પાસવર્ડ હોય, તો તેને AI ને આપતા પહેલા AKIA ને બદલે <AWS_ACCESS_KEY> જેવા પ્લેસહોલ્ડર્સ સાથે માસ્ક કરો.
એઆઈ જે કોડ બનાવે છે તે પણ તપાસો: એઆઈ કેટલીકવાર એવા ઉદાહરણો બનાવે છે જે સગવડતા માટે કોડમાં સીધા જ ગુપ્તને હાર્ડકોડ કરે છે. આ એક સુરક્ષા નબળાઈ છે. હકીકતમાં, સિક્રેટ્સને સિક્રેટ વૉલ્ટમાં રાખવામાં આવે છે (વોલ્ટ, AWS સિક્રેટ મેનેજર, એઝ્યુર કી વૉલ્ટ) અને રન ટાઈમ પર એન્વાયર્નમેન્ટ વેરિએબલ્સ તરીકે ઇન્જેક્ટ કરવામાં આવે છે.
આ ક્ષેત્રમાં અન્ય નૈતિક અને કાનૂની મર્યાદા: રક્ષણાત્મક ઉપયોગ. તમારી સિસ્ટમને સખત કરવા, નબળાઈઓ માટે સ્કેન કરવા અને લૉગ્સમાંથી હુમલાના નિશાન કાઢવા માટે AI નો ઉપયોગ કરો. બીજાની સિસ્ટમમાં અનધિકૃત ઍક્સેસ, અનધિકૃત સ્કેનિંગ અથવા હુમલાનું સાધન બનાવવું ગેરકાયદેસર છે અને આ પ્લેટફોર્મની બહાર છે. હંમેશા એવી સિસ્ટમમાં કામ કરો કે જેના માટે તમારી પાસે સત્તા છે અને તમે કરાર દ્વારા લેખિત પરવાનગી મેળવી છે.
કયો ડેટા કયા વાહનમાં જાય છે?
ડેટા પ્રકાર
ઉદાહરણ
યોગ્ય વાહન
ડેટા ખોલો
સત્તાવાર દસ્તાવેજ, ઓપન સોર્સ કોડ
દરેક વાહન
આંતરિક ડેટા (ગુપ્ત નથી)
સામાન્ય આર્કિટેક્ચર ડાયાગ્રામ, સામાન્ય પાઇપલાઇન
સંસ્થા દ્વારા માન્ય વાહન
ગોપનીય/સંવેદનશીલ
ગુપ્ત, પ્રોડ IP/ટોપોલોજી, ગ્રાહક ડેટા
માત્ર સંસ્થા દ્વારા કરાર કરાયેલ વાહન, જેનો ડેટા તાલીમમાં જતો નથી; માસ્ક કરીને
ત્રણ નાના કેસો
કેસ 1 - સમય યોગ્ય જગ્યાએ મળ્યો હતો. એક DevOps એન્જિનિયરે જૂની 300-લાઇન જેનકિન્સ પાઇપલાઇનને GitHub ક્રિયાઓ પર ખસેડવામાં 6 કલાક ગાળ્યા. તેણે AI દ્વારા સ્ટેપ બાય સ્ટેપ સમજાવીને ડ્રાફ્ટ તૈયાર કરીને કામને 90 મિનિટ સુધી ઘટાડી દીધું. તેણે સ્ટેજિંગમાં AI દ્વારા ઉત્પાદિત દરેક પગલાને એક પછી એક ચકાસવામાં બચતો સમય પસાર કર્યો. AI એ યાંત્રિક અનુવાદ લીધો; માન્યતા માનવ સાથે રહી.
કેસ 2 - ચકાસણી આપત્તિ ટાળી. એક ટીમે AI ને ટેરાફોર્મ ક્લીનઅપ સ્ક્રિપ્ટ માટે પૂછ્યું. AI એ અસ્ખલિત કોડ આપ્યો; પરંતુ જ્યારે એન્જિનિયરે ટેરાફોર્મ પ્લાન ચલાવ્યો, ત્યારે તેણે શોધ્યું કે સ્ક્રિપ્ટે ઉપયોગમાં લેવાતા ઉત્પાદન ડેટાબેઝને કાઢી નાખવાની પણ યોજના બનાવી હતી - AI એ રિસોર્સ ફિલ્ટરને ખોટી રીતે ટાઇપ કર્યું હતું. ડ્રાય રનિંગ કલાકોના ડેટાના નુકશાનને અટકાવે છે.
કેસ 3 - સિક્રેટ લીકમાંથી પરત. "શા માટે તે ડિપ્લોય એરર" પૂછતી વખતે એક ઇન્ટર્નએ આખી .env ફાઇલને સાર્વજનિક ટૂલમાં પેસ્ટ કરી હતી જેમાં વાસ્તવિક ઉત્પાદન ડેટાબેઝ પાસવર્ડ અંદર હતો. સિનિયર એન્જિનિયરે તરત જ ચાવીઓ ફેરવી અને ફરી બનાવી. સાચો રસ્તો એ હતો કે પાસવર્ડને <DB_PASSWORD> સાથે માસ્ક કરવો અને માત્ર ભૂલ સંદેશ શેર કરવો.
ચાર નકલ કરી શકાય તેવા નમૂનાઓ
1) નોકરીની યોગ્યતાનું મૂલ્યાંકન:
તમારી ભૂમિકા: વરિષ્ઠ DevOps/SRE સલાહકાર. હું તમારા માટે એક ભૂમિકાનું વર્ણન કરીશ. મને કહો (1) શું આ એક ડ્રાફ્ટિંગ/વિશ્લેષણ કાર્ય છે જે AI ને સુરક્ષિત રીતે સોંપી શકાય છે, અથવા ઉત્પાદનને અસર કરતા નિર્ણાયક નિર્ણય છે; (2) જો તે ખોટું થાય તો સૌથી ખરાબ પરિણામ જણાવો; (3) ચકાસણીના પગલાં જણાવો કે જે અમલીકરણ પહેલાં કરવાની જરૂર છે. કાર્ય: [અહીં]
2) સુરક્ષિત સંદર્ભ આપવો (ગુપ્ત માસ્કિંગ):
નીચેની ભૂલનું વિશ્લેષણ કરો. મેં <PLACEHOLDER> સાથે તમામ રહસ્યોને ઢાંકી દીધા છે; તમે એ પણ સૂચવો છો કે સોલ્યુશનમાં ક્યારેય વાસ્તવિક રહસ્ય ન બનાવો, પ્લેસહોલ્ડરનો ઉપયોગ કરો અને કોડમાં રહસ્ય એમ્બેડ કરો, ગુપ્ત તિજોરીમાંથી વાંચો. ભૂલ/લોગ: [માસ્ક કરેલ સામગ્રી]
3) આદેશ ચકાસણી:
મને આ આદેશ સમજાવો: દરેક ફ્લેગ શું કરે છે, તે કયા ટૂલ સંસ્કરણને લાગુ પડે છે અને તેની સૌથી ખતરનાક આડઅસર લખો. આને પ્રોડમાં ચલાવતા પહેલા કરવા માટે છેલ્લે 3 ચેકની યાદી આપો. આદેશ: [અહીં]
4) લર્નિંગ/કન્સેપ્ટ ક્વેરી:
હું [કન્સેપ્ટ: દા.ત. [બ્લુ-ગ્રીન ડિપ્લોયમેન્ટ] ની વિભાવનાને સમજાવો જાણે તમે તેને DevOps એન્જિનિયરને સમજાવતા હોવ: તે શું કરે છે, તેનો ઉપયોગ ક્યારે કરવો, ક્યારે ન કરવો, 2 લાક્ષણિક ભૂલો. સંક્ષિપ્ત અને નક્કર બનો.
નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ
નબળા: "મને ડિપ્લોય સ્ક્રિપ્ટ લખો."
નિષ્કર્ષ: તે સ્પષ્ટ નથી કે કયું વાદળ, કયું સાધન, કયું વાતાવરણ; AI એક સામાન્ય, સંભવતઃ બિન-પ્રોડક સ્ક્રિપ્ટ બનાવે છે જે કોડમાં રહસ્યને એમ્બેડ કરે છે.
મજબૂત: "એક બેશ સ્ક્રિપ્ટનો ડ્રાફ્ટ લખો જે AWS ECS (સ્થિતિસ્થાપક કન્ટેનર સેવા) પર જમાવવામાં આવે છે. પ્રદેશ eu-central-1 છે, છબી ECR માંથી આવે છે. કોડમાં ક્યારેય રહસ્યો એમ્બેડ કરશો નહીં, AWS સિક્રેટ મેનેજર પાસેથી તેને વાંચો. જો દરેક પગલા પર કોઈ ભૂલ હોય, તો રોકો (-Weeuveri script-step-3-step-3) પહેલાં ચાલતા અટકો. ઉત્પાદન."
તફાવત: બીજો પ્રોમ્પ્ટ ક્લાઉડ, ટૂલ, પર્યાવરણ, સુરક્ષા નિયમ અને માન્યતા અપેક્ષા આપે છે — આઉટપુટ સીધું ઉપયોગી અને સુરક્ષિત છે.
સામાન્ય ભૂલો
- પ્રોમ્પ્ટમાં વાસ્તવિક રહસ્ય પેસ્ટ કરી રહ્યું છે. સૌથી સામાન્ય અને ખતરનાક ભૂલ. હંમેશા માસ્ક.
- સંદર્ભહીન પ્રોમ્પ્ટ. મેઘ, સંસ્કરણ, પર્યાવરણનો ઉલ્લેખ કર્યા વિના, ઇચ્છિત આઉટપુટ ઘણીવાર ખોટા સંસ્કરણ અથવા ખોટા આર્કિટેક્ચરનું હોય છે.
- ડ્રાય રનિંગ છોડવું. પ્લાનિંગ વિના અમલીકરણ/-ડ્રાય-રન એ DevOpsમાં સૌથી મોંઘો શોર્ટકટ છે.
- ઉત્પાદનમાં પ્રથમ પ્રયાસ કરી રહ્યા છીએ. દરેક નવા AI આઉટપુટને પહેલા ટેસ્ટિંગ/સ્ટેજિંગમાં ચલાવવામાં આવવું જોઈએ.
- "AIએ કહ્યું" સાથે જવાબદારી સોંપવી. જવાબદારી હંમેશા અમલીકરણ એન્જિનિયરની રહે છે.
- ભ્રામક ધ્વજ પર વિશ્વાસ કરવો. ક્વેરી વિના અસ્તિત્વમાં ન હોય તેવા આદેશ ફ્લેગનો અમલ.
સારાંશમાં
DevOps અને ક્લાઉડ AI; તે એક સહાયક છે જે ટેક્સ્ટ-સઘન કાર્યો જેમ કે પાઇપલાઇન, રૂપરેખાંકન, સ્ક્રિપ્ટ અને લોગમાં ખૂબ ઝડપ પૂરી પાડે છે. પરંતુ ઉત્પાદન, ગુપ્ત વ્યવસ્થાપન અને અંતિમ અમલીકરણને અસર કરતા નિર્ણયોની જવાબદારી સક્ષમ એન્જિનિયરની રહે છે. થ્રી-સ્ટેપ વેરિફિકેશન (સ્રોત સાથે જોડો, ડ્રાય ચલાવો, સિસ્ટમ ફિલ્ટરમાંથી પસાર થાઓ), ક્યારેય રહસ્યો લીક ન કરો અને માત્ર અધિકૃત સિસ્ટમ્સ પર જ રક્ષણાત્મક હેતુઓ માટે કામ કરવું એ આ મોડ્યુલના માર્ગદર્શક સિદ્ધાંતો છે.
એપ્લિકેશન કાર્ય
તમારા પોતાના કાર્ય (અથવા નમૂના પ્રોજેક્ટ)માંથી તાજેતરનું DevOps કાર્ય પસંદ કરો. (1) ઉપરના “જોબ સ્યુટેબિલિટી એસેસમેન્ટ” ટેમ્પલેટનો ઉપયોગ કરીને AI ને આ કાર્યનું વર્ણન કરો અને તેનું વર્ગીકરણ વાંચો. (2) જો તેમાં ગુપ્ત હોય, તો તેને માસ્ક કરીને સંદર્ભ લખાણ તૈયાર કરો. (3) થ્રી-સ્ટેપ વેરિફિકેશન સાથે AIનું આઉટપુટ તપાસો અને દરેક સ્ટેપ પર તમે શું સુધાર્યું તે એક વાક્યમાં નોંધો.
ચેકલિસ્ટ
- [ ] મેં મારા કાર્યને "સોપવા યોગ્ય કાર્ય" અથવા "નિર્ણાયક નિર્ણય" તરીકે વર્ગીકૃત કર્યું છે.
- [ ] મેં પ્રોમ્પ્ટમાં કોઈ વાસ્તવિક રહસ્યો પેસ્ટ કર્યા નથી; મેં તે બધાને પ્લેસહોલ્ડર સાથે માસ્ક કર્યા.
- મેં ક્લાઉડ, ટૂલ વર્ઝન અને પર્યાવરણ સંબંધિત પ્રોમ્પ્ટમાં સંદર્ભ ઉમેર્યો છે.
- [ ] મેં AI આઉટપુટને લાગુ કરતાં પહેલાં ડ્રાય રન/પ્લાન સાથે તપાસ્યું.
- [ ] મેં પ્રથમ પ્રયાસ ટેસ્ટ/સ્ટેજિંગ પર્યાવરણમાં કર્યો, પ્રોડમાં નહીં.
- [ ] મેં સંરક્ષણ હેતુઓ માટે માત્ર એવી સિસ્ટમ્સ પર કામ કર્યું જેમાં મારી પાસે સત્તા હતી.