గైడ్: అదే రన్నర్‌లో Git

Lucas Simon

19, మే 2024, ఆదివారం 8:46:48 PMకి

షేర్డ్ రన్నర్స్‌పై GitHub వర్క్‌ఫ్లోలను సమన్వయం చేయడం

GitHub చర్యలలో బహుళ వర్క్‌ఫ్లోలను నిర్వహించడం సవాలుగా ఉంటుంది, ప్రత్యేకించి మీరు అదే స్వీయ-హోస్ట్ చేసిన రన్నర్‌లో వాటిని అమలు చేయడానికి అవసరమైనప్పుడు. మీరు codeql.yml మరియు snyk-zap.yml వంటి విభిన్న వర్క్‌ఫ్లోల కోసం వేర్వేరు YAML ఫైల్‌లను కలిగి ఉన్న సందర్భాల్లో, అవి నిర్దిష్ట సమూహం నుండి ఒకే రన్నర్‌పై నడుస్తాయని నిర్ధారించుకోవడం గమ్మత్తైనది.

రన్నర్‌కు స్పష్టంగా పేరు పెట్టకుండా రెండు వర్క్‌ఫ్లోల కోసం ఒకే రన్నర్‌ను ఉపయోగించడం లక్ష్యం, తద్వారా ఇతర వర్క్‌ఫ్లోలతో వైరుధ్యాలను నివారించడం. ఈ గైడ్ ప్రత్యేక YAML ఫైల్‌లలో వర్క్‌ఫ్లోలను కొనసాగిస్తూ సమకాలీకరణను సమర్ధవంతంగా సాధించడానికి సాధ్యమైన పరిష్కారాలను అన్వేషిస్తుంది.

ఆదేశం	వివరణ
jq	బాష్ స్క్రిప్ట్‌లో JSON అవుట్‌పుట్‌ను అన్వయించడానికి ఉపయోగించే తేలికపాటి మరియు సౌకర్యవంతమైన కమాండ్-లైన్ JSON ప్రాసెసర్.
head -n 1	మొదటి అందుబాటులో ఉన్న రన్నర్ IDని ఎంచుకోవడానికి ఇక్కడ ఉపయోగించిన ఫలితం యొక్క మొదటి పంక్తిని అవుట్‌పుట్ చేస్తుంది.
curl	URLలతో డేటాను బదిలీ చేయడానికి కమాండ్-లైన్ సాధనం, Bash స్క్రిప్ట్‌లో GitHub APIతో పరస్పర చర్య చేయడానికి ఉపయోగించబడుతుంది.
os.getenv()	GitHub టోకెన్ మరియు రిపోజిటరీ పేరును పొందడానికి ఉపయోగించే పైథాన్‌లోని ఎన్విరాన్‌మెంట్ వేరియబుల్‌లను తిరిగి పొందుతుంది.
requests.get()	పైథాన్ స్క్రిప్ట్‌లో GitHub యొక్క API నుండి అందుబాటులో ఉన్న రన్నర్‌లను పొందేందుకు ఉపయోగించే నిర్దిష్ట URLకి GET అభ్యర్థనను పంపుతుంది.
os.path.exists()	పైథాన్ స్క్రిప్ట్‌లో రన్నర్ ID ఫైల్ ఇప్పటికే ఉందో లేదో తెలుసుకోవడానికి, పేర్కొన్న మార్గం ఉనికిలో ఉందో లేదో తనిఖీ చేస్తుంది.
with open()	పైథాన్‌లోని ఫైల్ ఆపరేషన్‌ల కోసం సందర్భ మేనేజర్, రన్నర్ IDని ఫైల్‌కి చదవడానికి మరియు వ్రాయడానికి ఉపయోగిస్తారు.

షేర్డ్ రన్నర్స్‌తో వర్క్‌ఫ్లోలను సమన్వయం చేయడం

అందించిన స్క్రిప్ట్‌లు GitHub వర్క్‌ఫ్లోల కోసం రన్నర్ అసైన్‌మెంట్‌ను నిర్వహిస్తాయి. రన్నర్ ID ఇప్పటికే తాత్కాలిక ఫైల్‌లో నిల్వ చేయబడిందో లేదో తనిఖీ చేయడం ద్వారా బాష్ స్క్రిప్ట్ ప్రారంభమవుతుంది. కాకపోతే, అది ఉపయోగిస్తుంది curl అందుబాటులో ఉన్న రన్నర్‌ల కోసం GitHub APIని ప్రశ్నించడానికి మరియు jq JSON ప్రతిస్పందనను అన్వయించడానికి, మొదటి నిష్క్రియ రన్నర్‌ని ఎంచుకుని, దాని IDని సేవ్ చేయండి. పైథాన్ స్క్రిప్ట్‌ని ఉపయోగించడం ద్వారా ఇలాంటి కార్యాచరణను సాధిస్తుంది requests.get() GitHub API నుండి రన్నర్ సమాచారాన్ని పొందే పద్ధతి. స్క్రిప్ట్ ఉపయోగించి రన్నర్ ID ఇప్పటికే నిల్వ చేయబడిందో లేదో తనిఖీ చేస్తుంది os.path.exists() మరియు అది కాకపోతే సేవ్ చేస్తుంది.

రెండు స్క్రిప్ట్‌లు రన్నర్‌ను కేటాయించిన తర్వాత, నిల్వ చేయబడిన రన్నర్ IDని సూచించడం ద్వారా తదుపరి ఉద్యోగాల కోసం మళ్లీ ఉపయోగించబడుతుందని నిర్ధారిస్తుంది. పైథాన్ స్క్రిప్ట్‌లో, os.getenv() GitHub టోకెన్ మరియు రిపోజిటరీ కోసం ఎన్విరాన్‌మెంట్ వేరియబుల్‌లను తిరిగి పొందుతుంది మరియు with open() ఫైల్ కార్యకలాపాలను సురక్షితంగా నిర్వహించడానికి ఉపయోగించబడుతుంది. ఈ స్క్రిప్ట్‌లు బహుళ వర్క్‌ఫ్లోలను సమన్వయం చేయడంలో సహాయపడతాయి, అవి రన్నర్ పేరును హార్డ్‌కోడ్ చేయకుండా ఒకే రన్నర్‌పై నడుస్తాయని నిర్ధారిస్తుంది, వర్క్‌ఫ్లో ఎగ్జిక్యూషన్ నిర్వహణలో వాటిని ఫ్లెక్సిబుల్‌గా మరియు సమర్థవంతంగా చేస్తుంది.

GitHub చర్యల కోసం షేర్డ్ రన్నర్ స్ట్రాటజీని అమలు చేయడం

వర్క్‌ఫ్లోలు ఒకే రన్నర్‌పై నడుస్తాయని నిర్ధారించడానికి బాష్ స్క్రిప్టింగ్ మరియు 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 వర్క్‌ఫ్లోలను అమలు చేయడం