માર્ગદર્શિકા: સમાન રનર

Lucas Simon

રવિવાર, 19 મે, 2024 એ 08:08:37 PM વાગ્યે

શેર કરેલ દોડવીરો પર GitHub વર્કફ્લોનું સંકલન કરવું

GitHub ક્રિયાઓમાં બહુવિધ વર્કફ્લોનું સંચાલન કરવું પડકારરૂપ હોઈ શકે છે, ખાસ કરીને જ્યારે તમને તે જ સ્વ-હોસ્ટેડ રનર પર ચલાવવાની જરૂર હોય. એવા સંજોગોમાં જ્યાં તમારી પાસે વિવિધ વર્કફ્લો માટે અલગ YAML ફાઇલો હોય, જેમ કે codeql.yml અને snyk-zap.yml, ખાતરી કરવી કે તેઓ ચોક્કસ જૂથમાંથી સમાન રનર પર ચાલે છે તે મુશ્કેલ હોઈ શકે છે.

ધ્યેય એ છે કે બંને વર્કફ્લો માટે એક જ રનરનો ઉપયોગ સ્પષ્ટપણે રનરનું નામ આપ્યા વિના, જેથી કરીને અન્ય વર્કફ્લો સાથે તકરાર ટાળી શકાય. આ માર્ગદર્શિકા અલગ YAML ફાઇલોમાં વર્કફ્લો જાળવતી વખતે અસરકારક રીતે આ સિંક્રોનાઇઝેશન હાંસલ કરવા માટે શક્ય ઉકેલોની શોધ કરશે.

આદેશ	વર્ણન
jq	બૅશ સ્ક્રિપ્ટમાં JSON આઉટપુટને પાર્સ કરવા માટે ઉપયોગમાં લેવાતો હલકો અને લવચીક કમાન્ડ-લાઇન JSON પ્રોસેસર.
head -n 1	પરિણામની પ્રથમ લાઇનને આઉટપુટ કરે છે, જેનો ઉપયોગ પ્રથમ ઉપલબ્ધ રનર ID પસંદ કરવા માટે થાય છે.
curl	URL સાથે ડેટા ટ્રાન્સફર કરવા માટે કમાન્ડ-લાઇન ટૂલ, Bash સ્ક્રિપ્ટમાં GitHub ના API સાથે ક્રિયાપ્રતિક્રિયા કરવા માટે વપરાય છે.
os.getenv()	GitHub ટોકન અને રિપોઝીટરી નામ મેળવવા માટે ઉપયોગમાં લેવાતા પાયથોનમાં પર્યાવરણ ચલોને પુનઃપ્રાપ્ત કરે છે.
requests.get()	Python સ્ક્રિપ્ટમાં GitHub ના API માંથી ઉપલબ્ધ દોડવીરોને લાવવા માટે ઉપયોગમાં લેવાતા ઉલ્લેખિત URL પર GET વિનંતી મોકલે છે.
os.path.exists()	સ્પષ્ટ કરેલ પાથ અસ્તિત્વમાં છે કે કેમ તે ચકાસે છે, રનર ID ફાઇલ પાયથોન સ્ક્રિપ્ટમાં પહેલેથી હાજર છે કે કેમ તે નિર્ધારિત કરવા માટે વપરાય છે.
with open()	Python માં ફાઇલ ઑપરેશન માટે સંદર્ભ વ્યવસ્થાપક, ફાઇલમાં રનર ID વાંચવા અને લખવા માટે વપરાય છે.

વહેંચાયેલ દોડવીરો સાથે વર્કફ્લોનું સંકલન કરવું

પ્રદાન કરેલ સ્ક્રિપ્ટ્સ GitHub વર્કફ્લો માટે રનર અસાઇનમેન્ટનું સંચાલન કરે છે. Bash સ્ક્રિપ્ટ તપાસ કરીને શરૂ થાય છે કે શું રનર ID પહેલેથી જ અસ્થાયી ફાઇલમાં સંગ્રહિત છે. જો નહિં, તો તે વાપરે છે curl ઉપલબ્ધ દોડવીરો માટે GitHub ના API ને પૂછવા માટે અને jq JSON પ્રતિસાદને પાર્સ કરવા માટે, પ્રથમ નિષ્ક્રિય રનરને પસંદ કરીને અને તેનું ID સાચવીને. પાયથોન સ્ક્રિપ્ટનો ઉપયોગ કરીને સમાન કાર્યક્ષમતા પ્રાપ્ત કરે છે requests.get() GitHub ના API માંથી રનર માહિતી મેળવવાની પદ્ધતિ. સ્ક્રિપ્ટ પછી તપાસ કરે છે કે શું રનર ID નો ઉપયોગ કરીને પહેલેથી જ સંગ્રહિત છે os.path.exists() અને જો નહિં તો સાચવે છે.

બંને સ્ક્રિપ્ટો એ સુનિશ્ચિત કરે છે કે એકવાર દોડવીરને સોંપવામાં આવે, તે સંગ્રહિત રનર ID નો સંદર્ભ આપીને અનુગામી નોકરીઓ માટે ફરીથી ઉપયોગમાં લેવાશે. પાયથોન સ્ક્રિપ્ટમાં, 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 ફાઇલોમાં સતત રનર વપરાશની ખાતરી કરવી

સંકલિત વર્કફ્લો એક્ઝેક્યુશન માટે Python અને GitHub ક્રિયાઓનો ઉપયોગ

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 પાઇપલાઇન્સ માટે અસરકારક વ્યૂહરચના બનાવે છે. આ પદ્ધતિઓનો અમલ કરીને, સંસ્થાઓ તેમના વર્કફ્લો એક્ઝિક્યુશનને સુવ્યવસ્થિત કરી શકે છે અને રાહ જોવાના સમયને ઘટાડી શકે છે, આખરે ઉત્પાદકતામાં સુધારો કરી શકે છે અને વિકાસની સરળ પ્રક્રિયા જાળવી શકે છે.

માર્ગદર્શિકા: સમાન રનર પર ગિટ વર્કફ્લો ચલાવવું