வழிகாட்டி: அதே

Lucas Simon

ஞாயிறு, 19 மே, 2024 ’அன்று’ பிற்பகல் 8:48:29

பகிரப்பட்ட ரன்னர்களில் கிட்ஹப் பணிப்பாய்வுகளை ஒருங்கிணைத்தல்

GitHub செயல்களில் பல பணிப்பாய்வுகளை நிர்வகிப்பது சவாலானது, குறிப்பாக நீங்கள் அதே சுய-ஹோஸ்ட் செய்யப்பட்ட ரன்னரில் அவற்றை இயக்க வேண்டும். codeql.yml மற்றும் snyk-zap.yml போன்ற வெவ்வேறு பணிப்பாய்வுகளுக்கான தனித்தனி YAML கோப்புகளை நீங்கள் வைத்திருக்கும் சூழ்நிலைகளில், அவை ஒரு குறிப்பிட்ட குழுவிலிருந்து ஒரே ரன்னரில் இயங்குவதை உறுதிசெய்வது தந்திரமானதாக இருக்கும்.

ரன்னரை வெளிப்படையாகப் பெயரிடாமல், இரண்டு பணிப்பாய்வுகளுக்கும் ஒரே ரன்னரைப் பயன்படுத்துவதே குறிக்கோள், இதன் மூலம் மற்ற பணிப்பாய்வுகளுடன் மோதல்களைத் தவிர்க்கிறது. தனித்தனி YAML கோப்புகளில் பணிப்பாய்வுகளை பராமரிக்கும் போது இந்த ஒத்திசைவை திறம்பட அடைய இந்த வழிகாட்டி சாத்தியமான தீர்வுகளை ஆராயும்.

கட்டளை	விளக்கம்
jq	பாஷ் ஸ்கிரிப்ட்டில் JSON வெளியீட்டை அலசுவதற்கு இலகுரக மற்றும் நெகிழ்வான கட்டளை வரி JSON செயலி பயன்படுத்தப்படுகிறது.
head -n 1	கிடைக்கக்கூடிய முதல் ரன்னர் ஐடியைத் தேர்ந்தெடுக்க, முடிவின் முதல் வரியை வெளியிடுகிறது.
curl	URLகள் மூலம் தரவை மாற்றுவதற்கான கட்டளை வரி கருவி, பாஷ் ஸ்கிரிப்ட்டில் GitHub இன் API உடன் தொடர்பு கொள்ளப் பயன்படுகிறது.
os.getenv()	கிட்ஹப் டோக்கன் மற்றும் களஞ்சியப் பெயரைப் பெறுவதற்குப் பயன்படுத்தப்படும் பைத்தானில் சூழல் மாறிகளை மீட்டெடுக்கிறது.
requests.get()	ஒரு குறிப்பிட்ட URL க்கு GET கோரிக்கையை அனுப்புகிறது, பைதான் ஸ்கிரிப்ட்டில் உள்ள GitHub இன் API இலிருந்து கிடைக்கும் ரன்னர்களைப் பெறப் பயன்படுகிறது.
os.path.exists()	பைதான் ஸ்கிரிப்ட்டில் ரன்னர் ஐடி கோப்பு ஏற்கனவே உள்ளதா என்பதைத் தீர்மானிக்க, குறிப்பிட்ட பாதை உள்ளதா என்பதைச் சரிபார்க்கிறது.
with open()	பைத்தானில் கோப்பு செயல்பாடுகளுக்கான சூழல் மேலாளர், ஒரு கோப்பில் ரன்னர் ஐடியைப் படிக்கவும் எழுதவும் பயன்படுகிறது.

பகிரப்பட்ட ரன்னர்களுடன் பணிப்பாய்வுகளை ஒருங்கிணைத்தல்

வழங்கப்பட்ட ஸ்கிரிப்ட்கள் GitHub பணிப்பாய்வுகளுக்கான ரன்னர் ஒதுக்கீட்டை நிர்வகிக்கின்றன. ரன்னர் ஐடி ஏற்கனவே ஒரு தற்காலிக கோப்பில் சேமிக்கப்பட்டுள்ளதா என்பதைச் சரிபார்ப்பதன் மூலம் பாஷ் ஸ்கிரிப்ட் தொடங்குகிறது. இல்லை என்றால், அது பயன்படுத்துகிறது curl கிடைக்கக்கூடிய ரன்னர்களுக்காக GitHub இன் API ஐ வினவ மற்றும் jq JSON பதிலை அலச, முதல் செயலற்ற ரன்னரைத் தேர்ந்தெடுத்து அதன் ஐடியைச் சேமிக்கவும். பைதான் ஸ்கிரிப்ட் இதைப் பயன்படுத்துவதன் மூலம் ஒத்த செயல்பாட்டை அடைகிறது requests.get() GitHub இன் API இலிருந்து ரன்னர் தகவலைப் பெறுவதற்கான முறை. ஸ்கிரிப்ட் ரன்னர் ஐடியைப் பயன்படுத்தி ஏற்கனவே சேமிக்கப்பட்டுள்ளதா என்பதைச் சரிபார்க்கிறது os.path.exists() இல்லை என்றால் சேமிக்கிறது.

இரண்டு ஸ்கிரிப்ட்களும் ஒரு ரன்னர் நியமிக்கப்பட்டவுடன், சேமிக்கப்பட்ட ரன்னர் ஐடியைக் குறிப்பிடுவதன் மூலம் அடுத்தடுத்த வேலைகளுக்கு அது மீண்டும் பயன்படுத்தப்படும் என்பதை உறுதி செய்கிறது. பைதான் எழுத்தில், os.getenv() GitHub டோக்கன் மற்றும் களஞ்சியத்திற்கான சூழல் மாறிகளை மீட்டெடுக்கிறது, மற்றும் with open() கோப்பு செயல்பாடுகளை பாதுகாப்பாக கையாள பயன்படுகிறது. இந்த ஸ்கிரிப்டுகள் பல பணிப்பாய்வுகளை ஒருங்கிணைக்க உதவுகின்றன, அவை ரன்னர் பெயரை ஹார்ட்கோட் செய்யாமல் ஒரே ரன்னரில் இயங்குவதை உறுதிசெய்து, பணிப்பாய்வு செயல்படுத்தலை நிர்வகிப்பதில் நெகிழ்வானதாகவும் திறமையானதாகவும் இருக்கும்.

GitHub செயல்களுக்கான பகிரப்பட்ட ரன்னர் உத்தியை செயல்படுத்துதல்

பாஷ் ஸ்கிரிப்டிங் மற்றும் கிட்ஹப் ஆக்ஷன்களைப் பயன்படுத்தி ஒரே ரன்னரில் பணிப்பாய்வுகள் இயங்குவதை உறுதிசெய்யவும்

# A script to manage runner assignment
#!/bin/bash

# Check if a runner is already assigned
RUNNER_ID=$(cat /tmp/runner_id)

if [ -z "$RUNNER_ID" ]; then
  # No runner assigned yet, pick one and save its ID
  RUNNER_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_id
fi

echo "Using runner $RUNNER_ID"

# Proceed with the workflow using the assigned runner

தனித்தனி YAML கோப்புகளில் நிலையான ரன்னர் பயன்பாட்டை உறுதி செய்தல்

பைதான் மற்றும் கிட்ஹப் செயல்களைப் பயன்படுத்தி ஒருங்கிணைந்த பணிப்பாய்வு செயல்படுத்தல்

import requests
import os

# GitHub API token and repository
GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')
REPO = os.getenv('GITHUB_REPOSITORY')

# Function to get an available runner
def 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 assigned
if 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 பைப்லைன்களுக்கான பயனுள்ள உத்தியாக அமைகிறது. இந்த முறைகளை செயல்படுத்துவதன் மூலம், நிறுவனங்கள் தங்கள் பணிப்பாய்வு செயல்படுத்தலை நெறிப்படுத்தலாம் மற்றும் காத்திருப்பு நேரத்தை குறைக்கலாம், இறுதியில் உற்பத்தித்திறனை மேம்படுத்தலாம் மற்றும் ஒரு மென்மையான வளர்ச்சி செயல்முறையை பராமரிக்கலாம்.

வழிகாட்டி: அதே ரன்னரில் Git பணிப்பாய்வுகளை இயக்குதல்