പങ്കിട്ട റണ്ണേഴ്സിൽ GitHub വർക്ക്ഫ്ലോകൾ ഏകോപിപ്പിക്കുന്നു
GitHub പ്രവർത്തനങ്ങളിൽ ഒന്നിലധികം വർക്ക്ഫ്ലോകൾ കൈകാര്യം ചെയ്യുന്നത് വെല്ലുവിളി നിറഞ്ഞതാണ്, പ്രത്യേകിച്ചും നിങ്ങൾക്ക് അവ ഒരേ സ്വയം-ഹോസ്റ്റഡ് റണ്ണറിൽ പ്രവർത്തിക്കേണ്ടിവരുമ്പോൾ. codeql.yml, snyk-zap.yml എന്നിങ്ങനെ വ്യത്യസ്ത വർക്ക്ഫ്ലോകൾക്കായി നിങ്ങൾക്ക് വെവ്വേറെ YAML ഫയലുകൾ ഉള്ള സാഹചര്യത്തിൽ, ഒരു പ്രത്യേക ഗ്രൂപ്പിൽ നിന്നുള്ള ഒരേ റണ്ണറിലാണ് അവ പ്രവർത്തിക്കുന്നതെന്ന് ഉറപ്പാക്കുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമാണ്.
റണ്ണറെ വ്യക്തമായി പേരിടാതെ രണ്ട് വർക്ക്ഫ്ലോകൾക്കും ഒരേ റണ്ണറെ ഉപയോഗിക്കുക എന്നതാണ് ലക്ഷ്യം, അതുവഴി മറ്റ് വർക്ക്ഫ്ലോകളുമായുള്ള വൈരുദ്ധ്യങ്ങൾ ഒഴിവാക്കുക. പ്രത്യേക YAML ഫയലുകളിൽ വർക്ക്ഫ്ലോകൾ നിലനിർത്തിക്കൊണ്ടുതന്നെ ഈ സമന്വയം കാര്യക്ഷമമായി കൈവരിക്കുന്നതിന് സാധ്യമായ പരിഹാരങ്ങൾ ഈ ഗൈഡ് പര്യവേക്ഷണം ചെയ്യും.
| കമാൻഡ് | വിവരണം |
|---|---|
| jq | ബാഷ് സ്ക്രിപ്റ്റിൽ JSON ഔട്ട്പുട്ട് പാഴ്സ് ചെയ്യാൻ ഉപയോഗിക്കുന്ന ഭാരം കുറഞ്ഞതും വഴക്കമുള്ളതുമായ കമാൻഡ്-ലൈൻ JSON പ്രൊസസർ. |
| head -n 1 | ലഭ്യമായ ആദ്യ റണ്ണർ ഐഡി തിരഞ്ഞെടുക്കാൻ ഇവിടെ ഉപയോഗിച്ച ഫലത്തിൻ്റെ ആദ്യ വരി ഔട്ട്പുട്ട് ചെയ്യുന്നു. |
| curl | URL-കൾ ഉപയോഗിച്ച് ഡാറ്റ കൈമാറുന്നതിനുള്ള കമാൻഡ്-ലൈൻ ടൂൾ, ബാഷ് സ്ക്രിപ്റ്റിൽ GitHub-ൻ്റെ API-യുമായി സംവദിക്കാൻ ഉപയോഗിക്കുന്നു. |
| os.getenv() | GitHub ടോക്കണും റിപ്പോസിറ്ററി നാമവും ലഭിക്കാൻ ഉപയോഗിക്കുന്ന പൈത്തണിലെ പരിസ്ഥിതി വേരിയബിളുകൾ വീണ്ടെടുക്കുന്നു. |
| requests.get() | പൈത്തൺ സ്ക്രിപ്റ്റിലെ GitHub-ൻ്റെ API-യിൽ നിന്ന് ലഭ്യമായ റണ്ണർമാരെ ലഭ്യമാക്കാൻ ഉപയോഗിക്കുന്ന ഒരു നിർദ്ദിഷ്ട URL-ലേക്ക് ഒരു GET അഭ്യർത്ഥന അയയ്‌ക്കുന്നു. |
| os.path.exists() | പൈത്തൺ സ്ക്രിപ്റ്റിൽ റണ്ണർ ഐഡി ഫയൽ ഉണ്ടോ എന്ന് നിർണ്ണയിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു നിർദ്ദിഷ്ട പാത്ത് നിലവിലുണ്ടോ എന്ന് പരിശോധിക്കുന്നു. |
| with open() | പൈത്തണിലെ ഫയൽ പ്രവർത്തനങ്ങൾക്കായുള്ള സന്ദർഭ മാനേജർ, ഒരു ഫയലിലേക്ക് റണ്ണർ ഐഡി വായിക്കാനും എഴുതാനും ഉപയോഗിക്കുന്നു. |
പങ്കിട്ട റണ്ണേഴ്സുമായി വർക്ക്ഫ്ലോകൾ ഏകോപിപ്പിക്കുക
നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ GitHub വർക്ക്ഫ്ലോകൾക്കുള്ള റണ്ണർ അസൈൻമെൻ്റ് കൈകാര്യം ചെയ്യുന്നു. ഒരു റണ്ണർ ഐഡി ഇതിനകം ഒരു താൽക്കാലിക ഫയലിൽ സംഭരിച്ചിട്ടുണ്ടോ എന്ന് പരിശോധിച്ച് ബാഷ് സ്ക്രിപ്റ്റ് ആരംഭിക്കുന്നു. ഇല്ലെങ്കിൽ, അത് ഉപയോഗിക്കുന്നു curl ലഭ്യമായ റണ്ണർമാർക്കായി GitHub-ൻ്റെ API അന്വേഷിക്കാനും jq JSON പ്രതികരണം പാഴ്സ് ചെയ്യുന്നതിന്, ആദ്യത്തെ നിഷ്‌ക്രിയ റണ്ണറെ തിരഞ്ഞെടുത്ത് അതിൻ്റെ ഐഡി സംരക്ഷിക്കുന്നു. പൈത്തൺ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നതിലൂടെ സമാനമായ പ്രവർത്തനക്ഷമത കൈവരിക്കുന്നു requests.get() GitHub-ൻ്റെ API-ൽ നിന്ന് റണ്ണർ വിവരങ്ങൾ ലഭ്യമാക്കുന്നതിനുള്ള രീതി. ഒരു റണ്ണർ ഐഡി ഇതിനകം ഉപയോഗിച്ച് സംഭരിച്ചിട്ടുണ്ടോ എന്ന് സ്ക്രിപ്റ്റ് പരിശോധിക്കുന്നു os.path.exists() ഇല്ലെങ്കിൽ സംരക്ഷിക്കുകയും ചെയ്യുന്നു.
ഒരിക്കൽ ഒരു റണ്ണറെ അസൈൻ ചെയ്‌താൽ, സംഭരിച്ച റണ്ണർ ഐഡി റഫറൻസ് ചെയ്‌ത് തുടർന്നുള്ള ജോലികൾക്കായി അത് വീണ്ടും ഉപയോഗിക്കുമെന്ന് രണ്ട് സ്‌ക്രിപ്റ്റുകളും ഉറപ്പാക്കുന്നു. പൈത്തൺ ലിപിയിൽ, os.getenv() GitHub ടോക്കണിനും റിപ്പോസിറ്ററിക്കുമുള്ള പരിസ്ഥിതി വേരിയബിളുകൾ വീണ്ടെടുക്കുന്നു, കൂടാതെ with open() ഫയൽ പ്രവർത്തനങ്ങൾ സുരക്ഷിതമായി കൈകാര്യം ചെയ്യാൻ ഉപയോഗിക്കുന്നു. ഈ സ്ക്രിപ്റ്റുകൾ ഒന്നിലധികം വർക്ക്ഫ്ലോകൾ ഏകോപിപ്പിക്കാൻ സഹായിക്കുന്നു, റണ്ണർ നെയിം ഹാർഡ്കോഡ് ചെയ്യാതെ ഒരേ റണ്ണറിലാണ് അവ പ്രവർത്തിക്കുന്നത് എന്ന് ഉറപ്പുവരുത്തുകയും വർക്ക്ഫ്ലോ എക്സിക്യൂഷൻ കൈകാര്യം ചെയ്യുന്നതിൽ അവയെ വഴക്കമുള്ളതും കാര്യക്ഷമവുമാക്കുകയും ചെയ്യുന്നു.
GitHub പ്രവർത്തനങ്ങൾക്കായി ഒരു പങ്കിട്ട റണ്ണർ തന്ത്രം നടപ്പിലാക്കുന്നു
ഒരേ റണ്ണറിൽ വർക്ക്ഫ്ലോകൾ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ ബാഷ് സ്ക്രിപ്റ്റിംഗും GitHub പ്രവർത്തനങ്ങളും ഉപയോഗിക്കുന്നു
# A script to manage runner assignment#!/bin/bash# Check if a runner is already assignedRUNNER_ID=$(cat /tmp/runner_id)if [ -z "$RUNNER_ID" ]; then# No runner assigned yet, pick one and save its IDRUNNER_ID=$(curl -s -H "Authorization: token $GITHUB_TOKEN" \https://api.github.com/repos/$GITHUB_REPOSITORY/actions/runners |jq -r '.runners[] | select(.status=="online" and .busy==false) | .id' | head -n 1)echo $RUNNER_ID > /tmp/runner_idfiecho "Using runner $RUNNER_ID"# Proceed with the workflow using the assigned runner
പ്രത്യേക YAML ഫയലുകളിൽ സ്ഥിരമായ റണ്ണർ ഉപയോഗം ഉറപ്പാക്കുന്നു
കോർഡിനേറ്റഡ് വർക്ക്ഫ്ലോ എക്സിക്യൂഷനുവേണ്ടി പൈത്തണും GitHub പ്രവർത്തനങ്ങളും ഉപയോഗിക്കുന്നു
import requestsimport os# GitHub API token and repositoryGITHUB_TOKEN = os.getenv('GITHUB_TOKEN')REPO = os.getenv('GITHUB_REPOSITORY')# Function to get an available runnerdef get_runner():url = f"https://api.github.com/repos/{REPO}/actions/runners"headers = {'Authorization': f'token {GITHUB_TOKEN}'}response = requests.get(url, headers=headers)runners = response.json()['runners']for runner in runners:if runner['status'] == 'online' and not runner['busy']:return runner['id']return None# Check if a runner is already assignedif not os.path.exists('/tmp/runner_id'):runner_id = get_runner()with open('/tmp/runner_id', 'w') as f:f.write(str(runner_id))else:with open('/tmp/runner_id', 'r') as f:runner_id = f.read()print(f"Using runner {runner_id}")
GitHub പ്രവർത്തനങ്ങളിൽ കാര്യക്ഷമമായ റണ്ണർ മാനേജ്മെൻ്റ്
ഒരേ സ്വയം-ഹോസ്റ്റഡ് റണ്ണറിൽ വർക്ക്ഫ്ലോകൾ പ്രവർത്തിക്കേണ്ട സാഹചര്യങ്ങളിൽ, റണ്ണർ ലഭ്യത ഉറപ്പാക്കുകയും വൈരുദ്ധ്യങ്ങൾ കുറയ്ക്കുകയും ചെയ്യുക എന്നതാണ് പ്രധാന പരിഗണന. മുമ്പത്തെ സ്ക്രിപ്റ്റുകളിൽ കാണുന്നത് പോലെ, പങ്കിട്ട റണ്ണർ സ്ട്രാറ്റജി ഉപയോഗിച്ച്, ഒരു റണ്ണറെ ജോലിക്ക് നിയോഗിച്ചുകഴിഞ്ഞാൽ, തുടർന്നുള്ള ജോലികൾ അതേ റണ്ണറെയാണ് ഉപയോഗിക്കുന്നത്. സങ്കീർണ്ണമായ CI/CD പൈപ്പ് ലൈനുകളിൽ ഇത് പ്രത്യേകിച്ചും ഗുണം ചെയ്യും, അവിടെ അവസ്ഥ നിലനിർത്തുകയോ കാഷെ ചെയ്ത വിഭവങ്ങൾ ഉപയോഗപ്പെടുത്തുകയോ ചെയ്യുന്നത് നിർണായകമാണ്.
പരിഗണിക്കേണ്ട മറ്റൊരു വശം റണ്ണർ ഉപയോഗം ഒപ്റ്റിമൈസ് ചെയ്യുക എന്നതാണ്. ലഭ്യതയുടെ അടിസ്ഥാനത്തിൽ റണ്ണർമാരെ ചലനാത്മകമായി തിരഞ്ഞെടുത്ത് നിയോഗിക്കുന്നതിലൂടെ, ഓർഗനൈസേഷനുകൾക്ക് അവരുടെ വിഭവങ്ങൾ മികച്ച രീതിയിൽ കൈകാര്യം ചെയ്യാൻ കഴിയും. അത്തരം തന്ത്രങ്ങൾ നടപ്പിലാക്കുന്നത് കാര്യക്ഷമത മെച്ചപ്പെടുത്തുക മാത്രമല്ല, ക്യൂവിൽ വർക്ക്ഫ്ലോകൾ ചെലവഴിക്കുന്ന സമയം കുറയ്ക്കുകയും, ലഭ്യമായ ഒരു റണ്ണറിനായി കാത്തിരിക്കുകയും ചെയ്യുന്നു. ഈ സമീപനം മറ്റ് CI/CD ടൂളുകളിലേക്കും പ്ലാറ്റ്‌ഫോമുകളിലേക്കും വ്യാപിപ്പിക്കാം, ഇത് വിവിധ ഓട്ടോമേഷൻ ആവശ്യങ്ങൾക്കുള്ള ഒരു ബഹുമുഖ പരിഹാരമാക്കി മാറ്റുന്നു.
പങ്കിട്ട റണ്ണറുകളിൽ വർക്ക്ഫ്ലോകൾ ഏകോപിപ്പിക്കുന്നതിനെക്കുറിച്ചുള്ള പൊതുവായ ചോദ്യങ്ങൾ
- ഒരു നിർദ്ദിഷ്ട റണ്ണർ എപ്പോഴും ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഞാൻ എങ്ങനെ ഉറപ്പാക്കും?
- ഉപയോഗിക്കുക runs-on റണ്ണർ ഗ്രൂപ്പ് അല്ലെങ്കിൽ കൃത്യമായ റണ്ണർ പേര് വ്യക്തമാക്കുന്നതിന് നിങ്ങളുടെ YAML ഫയലിൽ കീ.
- എനിക്ക് വർക്ക്ഫ്ലോകളിലേക്ക് റണ്ണർമാരെ ഡൈനാമിക് ആയി അസൈൻ ചെയ്യാൻ കഴിയുമോ?
- അതെ, സ്ക്രിപ്റ്റുകൾ ഉപയോഗിച്ച് ലഭ്യമായ റണ്ണേഴ്‌സിനെ അന്വേഷിക്കുകയും ചലനാത്മകമായി അവരെ അസൈൻ ചെയ്യുകയും ചെയ്യുക.
- തിരക്കേറിയ അന്തരീക്ഷത്തിൽ റണ്ണർ വൈരുദ്ധ്യങ്ങൾ എങ്ങനെ കൈകാര്യം ചെയ്യാം?
- റണ്ണർ അലോക്കേഷൻ ഫലപ്രദമായി നിയന്ത്രിക്കുന്നതിന് ഒരു ക്യൂയിംഗ് സംവിധാനം നടപ്പിലാക്കുക അല്ലെങ്കിൽ വർക്ക്ഫ്ലോകൾക്ക് മുൻഗണന നൽകുക.
- റണ്ണേഴ്സ് ഇല്ലെങ്കിൽ എന്ത് സംഭവിക്കും?
- ഒരു റണ്ണർ ലഭ്യമാകുന്നത് വരെ വർക്ക്ഫ്ലോകൾ ക്യൂവായിരിക്കും. കാത്തിരിപ്പ് സമയം കുറയ്ക്കാൻ റണ്ണർ ഉപയോഗം ഒപ്റ്റിമൈസ് ചെയ്യുക.
- മറ്റ് CI/CD പ്ലാറ്റ്‌ഫോമുകൾക്കൊപ്പം എനിക്ക് ഈ സ്ക്രിപ്റ്റുകൾ ഉപയോഗിക്കാമോ?
- അതെ, റണ്ണർ മാനേജ്‌മെൻ്റിലേക്കുള്ള API ആക്‌സസ് ഉള്ള മറ്റ് പ്ലാറ്റ്‌ഫോമുകൾക്കായി ലോജിക് പൊരുത്തപ്പെടുത്താനാകും.
- വർക്ക്ഫ്ലോകൾക്കിടയിലുള്ള അവസ്ഥ എങ്ങനെ നിലനിർത്താം?
- ബന്ധപ്പെട്ട ജോലികൾക്കായി ഒരേ റണ്ണർ തന്നെ ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഉറപ്പുവരുത്തുക, സാധ്യമാകുന്നിടത്ത് കാഷിംഗ് സംവിധാനങ്ങൾ പ്രയോജനപ്പെടുത്തുക.
- ഈ സ്ക്രിപ്റ്റുകൾക്ക് എന്ത് അനുമതികൾ ആവശ്യമാണ്?
- നിങ്ങളുടെ GitHub ടോക്കണിന് ആവശ്യമായ സ്കോപ്പുകൾ ഉണ്ടെന്ന് ഉറപ്പാക്കുക repo ഒപ്പം workflow.
- ഒരേ റണ്ണറിൽ എനിക്ക് ഒന്നിലധികം വർക്ക്ഫ്ലോകൾ ഒരേസമയം പ്രവർത്തിപ്പിക്കാൻ കഴിയുമോ?
- സാധാരണ, ഇല്ല. ഓരോ ഓട്ടക്കാരനും ഒരു സമയം ഒരു ജോലി നിർവഹിക്കുന്നു. കൺകറൻസിക്കായി ഒന്നിലധികം റണ്ണറുകൾ ഉപയോഗിക്കുക.
- റണ്ണർ ഉപയോഗവും പ്രകടനവും ഞാൻ എങ്ങനെ നിരീക്ഷിക്കും?
- റണ്ണർ പ്രവർത്തനവും പ്രകടനവും ട്രാക്ക് ചെയ്യുന്നതിന് GitHub-ൻ്റെ ബിൽറ്റ്-ഇൻ മോണിറ്ററിംഗ് ടൂളുകളോ ബാഹ്യ സേവനങ്ങളോ ഉപയോഗിക്കുക.
ഉപസംഹാരം:
അതേ സ്വയം-ഹോസ്റ്റഡ് റണ്ണറിൽ പ്രവർത്തിക്കാൻ GitHub വർക്ക്ഫ്ലോകൾ കൈകാര്യം ചെയ്യുന്നത് കാര്യക്ഷമതയ്ക്കും സ്ഥിരതയ്ക്കും നിർണായകമാണ്. ചർച്ച ചെയ്ത ബാഷ്, പൈത്തൺ സ്ക്രിപ്റ്റുകൾ, റണ്ണർമാരെ ചലനാത്മകമായി നിയോഗിച്ച്, തുടർന്നുള്ള ജോലികൾ ഒരേ റണ്ണറെ ഉപയോഗിക്കുന്നുവെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് ശക്തമായ ഒരു പരിഹാരം നൽകുന്നു. ഈ സമീപനം വൈരുദ്ധ്യങ്ങൾ കുറയ്ക്കുകയും വിഭവ വിനിയോഗം ഒപ്റ്റിമൈസ് ചെയ്യുകയും ചെയ്യുന്നു, ഇത് സങ്കീർണ്ണമായ CI/CD പൈപ്പ് ലൈനുകൾക്കുള്ള ഫലപ്രദമായ തന്ത്രമാക്കി മാറ്റുന്നു. ഈ രീതികൾ നടപ്പിലാക്കുന്നതിലൂടെ, ഓർഗനൈസേഷനുകൾക്ക് അവരുടെ വർക്ക്ഫ്ലോ എക്സിക്യൂഷൻ കാര്യക്ഷമമാക്കാനും കാത്തിരിപ്പ് സമയം കുറയ്ക്കാനും ആത്യന്തികമായി ഉൽപ്പാദനക്ഷമത മെച്ചപ്പെടുത്താനും സുഗമമായ വികസന പ്രക്രിയ നിലനിർത്താനും കഴിയും.