ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് ഉപയോഗിച്ച് സിഐ/സിഡി പൈപ്പ്ലൈനുകൾ രൂപകൽപ്പന ചെയ്യുന്നു: GitHub ആക്ഷൻസ്, GitLab CI

നേട്ടങ്ങൾ:

• CI/CD ആശയം, പൈപ്പ്ലൈൻ അനാട്ടമി (ട്രിഗർ, ജോലി, സ്റ്റെപ്പ്, റണ്ണർ, ആർട്ടിഫാക്റ്റ്) എന്നിവയും GitHub പ്രവർത്തനങ്ങളും GitLab CI തമ്മിലുള്ള വ്യത്യാസങ്ങളും മനസിലാക്കാനും കൃത്രിമബുദ്ധി ശരിയായ സന്ദർഭത്തിൽ പൈപ്പ്ലൈനുകൾ നിർമ്മിക്കാനുമുള്ള കഴിവ്.
• ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് നിർമ്മിക്കുന്ന പൈപ്പ്ലൈനിലെ രഹസ്യ റഫറൻസുകൾ, അനുമതികൾ, വിളിക്കപ്പെടുന്ന ഘടകങ്ങളുടെ അസ്തിത്വം എന്നിവ പരിശോധിച്ച് സുരക്ഷിതമാക്കാനുള്ള കഴിവ്
• പ്ലെയിൻ ടെക്സ്റ്റിൽ രഹസ്യങ്ങൾ എഴുതാതിരിക്കുക, കുറഞ്ഞ അംഗീകാരം നൽകുക, CI-യിൽ നിന്ന് വേർപെടുത്തി വിന്യാസം നിയന്ത്രിക്കുക തുടങ്ങിയ തത്വങ്ങൾ പ്രയോഗിക്കാനുള്ള കഴിവ്

ആധുനിക സോഫ്‌റ്റ്‌വെയറിൻ്റെ ഹൃദയം ഓട്ടോമേറ്റഡ് പൈപ്പ്‌ലൈനാണ്, അതിലൂടെ കോഡ് ഒരു ഡെവലപ്പറുടെ കമ്പ്യൂട്ടറിൽ നിന്ന് സുരക്ഷിതമായി ഉപഭോക്താവിലേക്ക് എത്തുന്നതുവരെ. ഈ പൈപ്പിനെ CI/CD എന്ന് വിളിക്കുന്നു. CI (തുടർച്ചയുള്ള സംയോജനം) എന്നത് ഓരോ കോഡ് മാറ്റത്തിൻ്റെയും യാന്ത്രിക സമാഹരണവും പരിശോധനയുമാണ്; ഡവലപ്പർ കീബോർഡ് വിടുന്നതിനുമുമ്പ് ഒരു ബഗ് പിടിക്കുക എന്നതാണ് ഇതിൻ്റെ ഉദ്ദേശ്യം. CD (തുടർച്ചയായ ഡെലിവറി/വിന്യാസം) എന്നത് പരീക്ഷിച്ച കോഡിൻ്റെ സ്വയമേവ തയ്യാറാക്കൽ അല്ലെങ്കിൽ റിലീസ് പോലും ആണ്. ഈ ഘട്ടങ്ങൾ ക്രമത്തിൽ നിർവചിക്കുന്ന ഒരു കോൺഫിഗറേഷൻ ഫയലാണ് CI/CD പൈപ്പ്ലൈൻ - സാധാരണയായി YAML-ൽ (മനുഷ്യർക്ക് വായിക്കാൻ കഴിയുന്ന കോൺഫിഗറേഷൻ ടെക്സ്റ്റ് ഫോർമാറ്റിൽ) എഴുതിയിരിക്കുന്നു.

ഈ YAML ഫയലുകൾ കൈകൊണ്ട് എഴുതുന്നത് മടുപ്പിക്കുന്നതും വാചാലവും പിശക് സാധ്യതയുള്ളതുമാണ്; ഇൻഡൻ്റേഷൻ ഒരു സ്പേസിൽ തെന്നിമാറിയാൽ, മുഴുവൻ പൈപ്പ്ലൈനും തകരും. ഇവിടെയാണ് AI വരുന്നത്: ശരിയായ സന്ദർഭത്തിൽ, അത് സെക്കൻ്റുകൾക്കുള്ളിൽ ഒരു വർക്കിംഗ് ഡ്രാഫ്റ്റ് നിർമ്മിക്കുന്നു. എന്നാൽ ജനറേറ്റ് ചെയ്ത ഓരോ ഘട്ടവും എന്താണ് ചെയ്യുന്നതെന്ന് മനസിലാക്കുകയും സ്ഥിരീകരിക്കുകയും ചെയ്യേണ്ടത് നിങ്ങളുടെ ജോലിയാണ് - കാരണം ഇത് നിങ്ങളുടെ കോഡ് പ്രോഡിലേക്ക് കൊണ്ടുപോകുന്ന പൈപ്പാണ്.

CI/CD പൈപ്പ്ലൈനിൻ്റെ ശരീരഘടന

ഓരോ പൈപ്പ് ലൈനും നിരവധി അടിസ്ഥാന ആശയങ്ങൾ ഉൾക്കൊള്ളുന്നു. ഇവ അറിയാതെ നിങ്ങൾക്ക് AI ഔട്ട്പുട്ട് നിയന്ത്രിക്കാൻ കഴിയില്ല:

• ട്രിഗർ: പൈപ്പ്ലൈൻ ആരംഭിക്കുന്നത് എന്താണ്? സാധാരണയായി ഒരു ശാഖയിലേക്കുള്ള പുഷ്, ഒരു പുൾ അഭ്യർത്ഥന (ലയിപ്പിക്കാനുള്ള അഭ്യർത്ഥന), അല്ലെങ്കിൽ ഒരു ഷെഡ്യൂൾ.
• ജോലി: ഘട്ടങ്ങളുടെ ഒരു പരമ്പര നടപ്പിലാക്കുന്ന ലോജിക്കൽ യൂണിറ്റ്; ഉദാഹരണത്തിന് "ടെസ്റ്റ്", "ബിൽഡ്", "വിന്യസിക്കുക".
• ഘട്ടം: ഒരു ജോലിക്കുള്ളിൽ ഒരൊറ്റ കമാൻഡ് അല്ലെങ്കിൽ പ്രവർത്തനം.
• റണ്ണർ: ജോലികൾ പ്രവർത്തിക്കുന്ന വെർച്വൽ മെഷീൻ അല്ലെങ്കിൽ കണ്ടെയ്നർ.
• ആർട്ടിഫാക്‌റ്റ്: ഒരു ജോലി നിർമ്മിച്ചതും തുടർന്നുള്ള ജോലികൾ ഉപയോഗിക്കുന്നതുമായ ഔട്ട്‌പുട്ട് (ഉദാഹരണത്തിന്, ഒരു സമാഹരിച്ച ഫയൽ).
• രഹസ്യം: പൈപ്പ്‌ലൈൻ ഉപയോഗിക്കുന്നതും എന്നാൽ ശേഖരത്തിൽ പ്ലെയിൻ ടെക്‌സ്‌റ്റിൽ തുടരാൻ പാടില്ലാത്തതുമായ രഹസ്യ വിവരങ്ങൾ.

GitHub പ്രവർത്തനങ്ങൾ ഈ നിർവചനം .github/workflows/*.yml ഫയലുകളിൽ സൂക്ഷിക്കുന്നു; യൂണിറ്റ് വർക്ക്ഫ്ലോ → ജോലി → ഘട്ട ശ്രേണിയാണ്. മറുവശത്ത്, GitLab CI, .gitlab-ci.yml ഫയലിലെ ഘട്ടം → ജോലി ഘടന ഉപയോഗിക്കുന്നു. AI-ക്ക് രണ്ട് വാക്യഘടനകളും അറിയാം, എന്നാൽ ഏതാണ് നിങ്ങൾക്ക് വേണ്ടതെന്ന് നിങ്ങൾ വ്യക്തമായി പറയണം.

നുറുങ്ങ്: പൈപ്പ്ലൈനുകൾക്കായി AI-യോട് ആവശ്യപ്പെടുമ്പോൾ, എപ്പോഴും വ്യക്തമാക്കുക: പ്ലാറ്റ്ഫോം (GitHub പ്രവർത്തനങ്ങൾ അല്ലെങ്കിൽ GitLab CI), ഭാഷ/ചട്ടക്കൂട് (നോഡ്, .NET, പൈത്തൺ...), ട്രിഗർ, അത് വിന്യസിക്കണോ എന്ന്. ഈ നാല് വിവരങ്ങളും ഔട്ട്പുട്ടിൻ്റെ ഉപയോഗക്ഷമത ഇരട്ടിയാക്കുന്നു.

ഘട്ടം ഘട്ടമായി: AI ഉപയോഗിച്ച് ഒരു പൈപ്പ്ലൈൻ രൂപകൽപ്പന ചെയ്യുന്നു

1. ലക്ഷ്യം വ്യക്തമാക്കുക. "മെയിനിലേക്കുള്ള പുഷ് ഓൺ ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുക, ഇമേജ് നിർമ്മിക്കുക, പക്ഷേ ടാഗ് എറിയുമ്പോൾ മാത്രം വിന്യസിക്കുക".
2. അസ്ഥികൂടം നിർമ്മിക്കുക. അടിസ്ഥാന വർക്ക്ഫ്ലോയ്ക്കായി AI-യോട് ആവശ്യപ്പെടുക.
3. ഘട്ടങ്ങൾ വായിച്ച് മനസ്സിലാക്കുക. ഓരോ ഓട്ടവും ഉപയോഗവും ലൈൻ എന്താണ് ചെയ്യുന്നതെന്ന് പരിശോധിക്കുക.
4. രഹസ്യ റഫറൻസുകൾ പരിശോധിക്കുക. രഹസ്യങ്ങൾ ${{ secrets.NAME }} ഉപയോഗിച്ചാണോ അതോ അവ കോഡിൽ ഉൾച്ചേർത്തതാണോ?
5. പ്രാദേശികമായി ഇത് പരീക്ഷിക്കുക/CI. ഒരു ചെറിയ ടെസ്റ്റ് റിപ്പോസിറ്ററിയിൽ ഇത് പ്രവർത്തിപ്പിക്കുക, ചുവപ്പ്-പച്ച (ഫെയിൽ-പാസ്) സ്വഭാവം കാണുക.
6. ക്രമേണ വികസിപ്പിക്കുക. ആദ്യം CI (ടെസ്റ്റ്) ചേർക്കുക, തുടർന്ന് നിർമ്മിക്കുക, അവസാനം വിന്യസിക്കുക ചേർക്കുക.

സുരക്ഷ: പൈപ്പ്ലൈനിലെ രഹസ്യവും അനുമതിയും

രഹസ്യങ്ങൾ ഏറ്റവും കൂടുതൽ ചോരുന്ന സ്ഥലങ്ങളിൽ ഒന്നാണ് CI/CD. മൂന്ന് സുവർണ്ണ നിയമങ്ങൾ:

1. YAML-ൽ പ്ലെയിൻ ടെക്സ്റ്റിൽ ഒരിക്കലും രഹസ്യങ്ങൾ എഴുതരുത്. പ്ലാറ്റ്‌ഫോമിൻ്റെ രഹസ്യ ശേഖരം (GitHub സീക്രട്ട്‌സ്, GitLab CI/CD വേരിയബിളുകൾ) ഉപയോഗിച്ച് ${{ secrets.X }} ഉപയോഗിച്ച് വിളിക്കുക.
2. ഏറ്റവും കുറഞ്ഞ പദവി. പൈപ്പ് ലൈനിന് നിങ്ങൾ നൽകുന്ന ടോക്കണിന് ആവശ്യമായ അധികാരം മാത്രമേ ഉണ്ടാകൂ. അനുമതികൾ ഉപയോഗിച്ച് ഇത് ചുരുക്കുക: GitHub പ്രവർത്തനങ്ങളിൽ തടയുക.
3. ലോഗിൽ രഹസ്യം അമർത്തരുത്. echo $TOKEN പോലെയുള്ള വരികൾ ലോഗിലെ രഹസ്യം വെളിപ്പെടുത്തുന്നു. പ്ലാറ്റ്‌ഫോമുകൾ മറയ്ക്കുക, എന്നാൽ ശ്രദ്ധിക്കുക.

മുൻകരുതൽ: സൗകര്യാർത്ഥം, AI ചിലപ്പോഴൊക്കെ പാസ്‌വേഡ്: 123456 അല്ലെങ്കിൽ അതിവിശാലമായ അനുമതികൾ പോലെയുള്ള ഉൾച്ചേർത്ത മൂല്യങ്ങൾ ഇടുന്നു: സാമ്പിൾ പൈപ്പ് ലൈനുകളിൽ എല്ലാം എഴുതുക. എല്ലായ്‌പ്പോഴും ഇത് പരിഹരിക്കുക: രഹസ്യം റഫറൻസിലേക്ക് മാറ്റുക, അനുമതി ചുരുക്കുക.

താരതമ്യ ചാർട്ട്

ആശയം

GitHub പ്രവർത്തനങ്ങൾ

ജിറ്റ്‌ലാബ് സി.ഐ

കോൺഫിഗറേഷൻ ഫയൽ

.github/workflows/*.yml

.gitlab-ci.yml

കെട്ടിട യൂണിറ്റ്

വർക്ക്ഫ്ലോ → ജോലി → ഘട്ടം

ഘട്ടം → ജോലി

ട്രിഗർ

പത്ത്:

നിയമങ്ങൾ: / മാത്രം:

രഹസ്യം വിളിക്കുക

${{ രഹസ്യങ്ങൾ.NAME }}

$NAME (CI/CD വേരിയബിളുകൾ)

തയ്യാറായ ഘടകം

ഉപയോഗിക്കുന്നു: action@v4

ഉൾപ്പെടുന്നു: /ടെംപ്ലേറ്റ്

ഓട്ടക്കാരൻ

റൺ-ഓൺ:

ടാഗുകൾ:

മൂന്ന് മിനി കേസുകൾ

കേസ് 1 - 6 മണിക്കൂറും 40 മിനിറ്റും ആയി കുറച്ചു. ഒരു ടീം അവരുടെ മാനുവൽ ടെസ്റ്റ്-ബിൽഡ്-ഡിപ്ലോയ് പ്രോസസ് ഓട്ടോമേറ്റ് ചെയ്യാൻ ആഗ്രഹിച്ചു, എന്നാൽ ആർക്കും YAML-നെ പരിചിതമായിരുന്നില്ല. അവർ YZ നെ "Node.js പ്രോജക്റ്റ്, GitHub പ്രവർത്തനങ്ങൾ, npm ടെസ്റ്റ്, npm ബിൽഡ് ഇൻ പുഷ് ടു മെയിൻ, വി* ടാഗിൽ മാത്രം വിന്യസിക്കുക" എന്നാണ് വിശേഷിപ്പിച്ചത്. AI 40 വരികളുള്ള ഒരു പ്രവർത്തിക്കുന്ന അസ്ഥികൂടം നിർമ്മിച്ചു; ടീം ഓരോ ചുവടും പരിശോധിച്ച് 40 മിനിറ്റിനുള്ളിൽ ലൈവായി. അവർ അത് കൈകൊണ്ട് എഴുതിയിരുന്നെങ്കിൽ, അത് ഒരു ദിവസത്തെ ജോലിയാകുമായിരുന്നു.

കേസ് 2 - ആധികാരികത ഉറപ്പാക്കൽ ഒരു സുരക്ഷാ പാളിച്ച പിടിച്ചു. വർക്ക്ഫ്ലോ വിന്യസിക്കാൻ ഒരു എഞ്ചിനീയർ AI യോട് ആവശ്യപ്പെട്ടു. ഔട്ട്‌പുട്ടിൽ അനുമതികൾ ഉൾപ്പെടുന്നു: എഴുതുക-എല്ലാം — അതായത് ടോക്കണിന് ശേഖരം, പാക്കേജുകൾ, എല്ലാം എഴുതാം. എഞ്ചിനീയർ ഇത് ശ്രദ്ധിക്കുകയും അനുമതികളോടെ ഇത് ചുരുക്കുകയും ചെയ്തു: { ഉള്ളടക്കങ്ങൾ: വായിക്കുക, പാക്കേജുകൾ: എഴുതുക }. ഇത് മുഴുവൻ റിപ്പോസിറ്ററിയും മാറ്റിസ്ഥാപിക്കുന്ന ഹൈജാക്ക് ചെയ്ത ഡിപൻഡൻസിയുടെ അപകടസാധ്യത ഇല്ലാതാക്കി.

കേസ് 3 - ഭ്രമാത്മക പ്രവർത്തനം. ഒരു ടീം AI നിർദ്ദേശിച്ച ഉപയോഗങ്ങൾ നടത്തി: പ്രവർത്തനങ്ങൾ/ഡിപ്ലോയ്-ടു-aws@v3 ലൈൻ; അത്തരം ഔദ്യോഗിക നടപടികളൊന്നും ഉണ്ടായില്ല, AI പേര് ഉണ്ടാക്കി. "നടപടി കണ്ടെത്തിയില്ല" എന്ന് പറഞ്ഞ് പൈപ്പ് ലൈൻ പൊട്ടിത്തെറിച്ചു. പാഠം: മാർക്കറ്റ്‌പ്ലേസിൽ പരിശോധിച്ചുറപ്പിക്കുക: ഉപയോഗിക്കുന്ന ഓരോ ഘടകങ്ങളും യഥാർത്ഥത്തിൽ നിലവിലുണ്ട്.

പകർത്താവുന്ന നാല് ടെംപ്ലേറ്റുകൾ

1) അടിസ്ഥാന CI വർക്ക്ഫ്ലോ:

GitHub പ്രവർത്തനങ്ങൾക്കായി ഒരു CI വർക്ക്ഫ്ലോ എഴുതുക. പ്രോജക്റ്റ്: [ഭാഷ/ഫ്രെയിം വർക്ക്]. ട്രിഗർ: പ്രധാന ബ്രാഞ്ചിലേക്ക് അഭ്യർത്ഥന പുഷ് ചെയ്ത് വലിക്കുക. ഘട്ടങ്ങൾ: ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുക, ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുക, ലിൻ്റ് പ്രവർത്തിപ്പിക്കുക. വിന്യാസം ഇല്ല.Runner ubuntu-latest. രഹസ്യം ആവശ്യമില്ല. YAML വ്യാഖ്യാനിക്കുക.

2) വിന്യസിച്ച സിഡി വർക്ക്ഫ്ലോ (സുരക്ഷിതം):

[PLATFORM] എന്നതിനായുള്ള വിന്യാസ വർക്ക്ഫ്ലോ എഴുതുക. ഇത് 'v*' ടാഗിൽ മാത്രമേ പ്രവർത്തിക്കൂ. ലക്ഷ്യം: [മീഡിയ/ക്ലൗഡ്]. നിയമങ്ങൾ: - ഒരിക്കലും പ്ലെയിൻ ടെക്സ്റ്റിൽ രഹസ്യങ്ങൾ എഴുതരുത്, ${{ രഹസ്യങ്ങൾ ഉപയോഗിച്ച് അവരെ വിളിക്കുക.

3) നിലവിലുള്ള പൈപ്പ്ലൈൻ വിവരിക്കുക:

ഇനിപ്പറയുന്ന [പ്ലാറ്റ്ഫോം] പൈപ്പ് ലൈൻ വരിയായി വിവരിക്കുക: ഓരോ ജോലിയും എന്താണ് ചെയ്യുന്നത്, ഏത് ക്രമത്തിലാണ് അത് പ്രവർത്തിക്കുന്നത്, ഏത് രഹസ്യമാണ് അത് ഉപയോഗിക്കുന്നത്, അതിൻ്റെ രണ്ട് അപകടകരമായ പോയിൻ്റുകൾ എന്തൊക്കെയാണ്? അവസാനമായി, 3 മെച്ചപ്പെടുത്തലുകൾ നിർദ്ദേശിക്കുക. പൈപ്പ്ലൈൻ: [YAML ഉള്ളടക്കം]

4) പൈപ്പ് ലൈൻ വേഗത്തിലാക്കുക:

ഇനിപ്പറയുന്ന CI പൈപ്പ്ലൈൻ സാവധാനത്തിലാണ് പ്രവർത്തിക്കുന്നത് (ദൈർഘ്യം: [X min]). കാഷെ ഉപയോഗം, സമാന്തര ജോലികൾ, അനാവശ്യ നടപടികൾ എന്നിവ പരിശോധിക്കുക. 5 കൃത്യമായ, പ്രവർത്തനക്ഷമമായ ത്വരിതപ്പെടുത്തൽ നിർദ്ദേശങ്ങൾ നൽകുക, ഓരോന്നിൻ്റെയും കണക്കാക്കിയ ആഘാതം എഴുതുക. പൈപ്പ്ലൈൻ: [YAML]

ദുർബലമായ പ്രോംപ്റ്റ് / ശക്തമായ പ്രോംപ്റ്റ്

ദുർബലമായത്: "GitHub പ്രവർത്തനങ്ങളുടെ വർക്ക്ഫ്ലോ എഴുതുക."

ഫലം: ഏത് ഭാഷ, ഏത് ട്രിഗർ, വിന്യാസമുണ്ടോ എന്ന് വ്യക്തമല്ല; AI ഒരു ജനറിക് നോഡ് ഉദാഹരണം നൽകുന്നു, ഒരുപക്ഷേ നിങ്ങളുടെ പ്രോജക്റ്റിന് അനുയോജ്യമാകില്ല, കൂടാതെ രഹസ്യം ഹാർഡ്കോഡ് ചെയ്യാനും കഴിയും.

ശക്തമായത്: "GitHub പ്രവർത്തനങ്ങളുടെ വർക്ക്ഫ്ലോ എഴുതുക. പൈത്തൺ 3.12 പ്രോജക്റ്റ്, പുൾ അഭ്യർത്ഥനയിലും പ്രധാന പുഷിലും പൈറ്റെസ്റ്റ് + റഫ് പ്രവർത്തിപ്പിക്കുക; വിന്യസിക്കരുത്; പിപ്പ് കാഷെ ഉപയോഗിച്ച് ഡിപൻഡൻസികൾ ത്വരിതപ്പെടുത്തുക; രഹസ്യങ്ങളൊന്നും ആവശ്യമില്ല. അഭിപ്രായങ്ങൾക്കൊപ്പം YAML കയറ്റുമതി ചെയ്യുക."

വ്യത്യാസം: രണ്ടാമത്തെ പ്രോംപ്റ്റ് ഭാഷ, ട്രിഗർ, സ്കോപ്പ് (വിന്യാസം ഇല്ല), പ്രകടന പ്രതീക്ഷ, സുരക്ഷാ നിയന്ത്രണം എന്നിവ നൽകുന്നു. ഔട്ട്പുട്ട് നേരിട്ട് പ്രവർത്തിക്കുന്നു.

സാധാരണ തെറ്റുകൾ

• YAML-ൽ രഹസ്യം ഉൾച്ചേർക്കുന്നു. പ്ലെയിൻടെക്‌സ് പാസ്‌വേഡ്/ടോക്കൺ ആണ് ഏറ്റവും സാധാരണമായ CI അപകടസാധ്യത.
• അതിവിശാലമായ അനുമതി. എല്ലാം എഴുതുന്നതിന് പകരം ആവശ്യമായ ഏറ്റവും കുറഞ്ഞ അനുമതി നൽകുക.
• നിലവിലില്ലാത്ത പ്രവർത്തനത്തെ/ടെംപ്ലേറ്റിനെ ആശ്രയിക്കുന്നു. AI- നിർമ്മിത ഉപയോഗങ്ങൾ പരിശോധിക്കുക: മാർക്കറ്റ്പ്ലേസിലെ ലൈനുകൾ.
• CI യെ ആശയക്കുഴപ്പത്തിലാക്കുന്നു. എല്ലാ പുഷിലും ടെസ്റ്റ് പ്രവർത്തിപ്പിക്കാം, എന്നാൽ വിന്യാസം നിയന്ത്രിക്കുകയും അംഗീകരിക്കുകയും വേണം.
• കാഷെ ഉപയോഗിക്കുന്നില്ല. ഓരോ ഓട്ടത്തിലും ആദ്യം മുതൽ ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നത് പൈപ്പ്ലൈനിനെ മിനിറ്റുകൾ കൊണ്ട് മന്ദഗതിയിലാക്കുന്നു.
• പ്രധാന ശേഖരത്തിൽ നേരിട്ട് ആദ്യ വർക്ക്ഫ്ലോ ശ്രമിക്കുന്നു. ആദ്യം ഒരു ടെസ്റ്റ് റിപ്പോസിറ്ററിയിൽ പ്രവർത്തിപ്പിക്കുക.

ചുരുക്കത്തിൽ

CI/CD പൈപ്പ്ലൈനുകൾ യാന്ത്രിക പൈപ്പുകളാണ്, അത് ഉൽപ്പന്നത്തിലേക്ക് സുരക്ഷിതമായി കോഡ് നീക്കുകയും YAML ഉപയോഗിച്ച് നിർവചിക്കുകയും ചെയ്യുന്നു. GitHub Actions, GitLab CI എന്നിവയ്‌ക്കായി AI വേഗത്തിൽ പ്രവർത്തിക്കുന്ന ബ്ലൂപ്രിൻ്റുകൾ നിർമ്മിക്കുന്നു - എന്നാൽ പ്ലാറ്റ്‌ഫോം, ഭാഷ, ട്രിഗർ, വിന്യസിക്കുന്ന സ്കോപ്പ് എന്നിവയെക്കുറിച്ച് നിങ്ങൾ വ്യക്തമായിരിക്കണം. സുരക്ഷയിൽ മൂന്ന് നിയമങ്ങളുണ്ട്: റഫറൻസ് വഴി രഹസ്യങ്ങൾ വിളിക്കുക, മിനിമം പ്രത്യേകാവകാശങ്ങൾ നൽകുക, ലോഗിൽ രഹസ്യങ്ങൾ അച്ചടിക്കരുത്. ഓരോന്നും ഉപയോഗിക്കുന്നത്:/ഉൾപ്പെടെ: ഘടകം യഥാർത്ഥത്തിൽ നിലവിലുണ്ടെന്നും ഓരോ ഘട്ടവും എന്തുചെയ്യുന്നുവെന്നും പരിശോധിക്കേണ്ടത് നിങ്ങളുടെ ഉത്തരവാദിത്തമാണ്.

ആപ്ലിക്കേഷൻ ടാസ്ക്

ഒരു ലളിതമായ സാമ്പിൾ പ്രോജക്റ്റ് തിരഞ്ഞെടുക്കുക (നിങ്ങളുടെ ഭാഷയിൽ "ഹലോ വേൾഡ്" പോലും ചെയ്യും). മുകളിലുള്ള "അടിസ്ഥാന CI വർക്ക്ഫ്ലോ" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് AI ഒരു വർക്ക്ഫ്ലോ നിർമ്മിക്കട്ടെ. തുടർന്ന്: (1) ഓരോ ചുവടും എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങളുടെ സ്വന്തം വാക്കുകളിൽ എഴുതുക; (2) രഹസ്യങ്ങളൊന്നും ഉൾച്ചേർത്തിട്ടില്ലെന്നും അനുമതികൾ ഇടുങ്ങിയതാണെന്നും സ്ഥിരീകരിക്കുക; (3) സാധ്യമെങ്കിൽ, അത് ഒരു ടെസ്റ്റ് ടാങ്കിൽ ഓടിച്ച് ചുവപ്പ്-പച്ച സ്വഭാവം നിരീക്ഷിക്കുക.

ചെക്ക്ലിസ്റ്റ്

• [ ] ഞാൻ പ്ലാറ്റ്ഫോം, ഭാഷ/ചട്ടക്കൂട്, ട്രിഗർ, വിന്യസിക്കൽ സ്കോപ്പ് എന്നിവ എൻ്റെ പ്രോംപ്റ്റിലേക്ക് ചേർത്തു.
• [ ] സൃഷ്ടിച്ച YAML-ൽ ഓരോ ജോലിയും ഘട്ടവും എന്താണ് ചെയ്യുന്നതെന്ന് ഞാൻ മനസ്സിലാക്കുന്നു.
• [ ] ഒരു രഹസ്യവും പ്ലെയിൻ ടെക്സ്റ്റ് അല്ല; എല്ലാ ${{ secrets.X }} / CI വേരിയബിൾ.
• [ ] ഞാൻ അനുമതികൾ മിനിമം അതോറിറ്റിയിലേക്ക് ചുരുക്കി.
• [ ] വിളിക്കപ്പെടുന്ന എല്ലാ പ്രവർത്തനങ്ങളും/ടെംപ്ലേറ്റുകളും യഥാർത്ഥത്തിൽ നിലവിലുണ്ടെന്ന് ഞാൻ പരിശോധിച്ചു.
• [ ] ഞാൻ വിന്യാസ ഘട്ടം അംഗീകാരം/സംരക്ഷണം ഉപയോഗിച്ച് നിയന്ത്രിച്ചു.