Guide: Köra Git-arbetsflöden på samma löpare

Koordinera GitHub-arbetsflöden på delade löpare

Att hantera flera arbetsflöden i GitHub Actions kan vara utmanande, särskilt när du behöver dem för att köra på samma självvärdade löpare. I scenarier där du har separata YAML-filer för olika arbetsflöden, som codeql.yml och snyk-zap.yml, kan det vara svårt att se till att de körs på samma löpare från en specifik grupp.

Målet är att använda samma löpare för båda arbetsflödena utan att uttryckligen namnge löparen, och därigenom undvika konflikter med andra arbetsflöden. Den här guiden kommer att utforska möjliga lösningar för att uppnå denna synkronisering effektivt samtidigt som arbetsflödena bibehålls i separata YAML-filer.

Koordinera arbetsflöden med delade löpare

De tillhandahållna skripten hanterar löpartilldelning för GitHub-arbetsflöden. Bash-skriptet börjar med att kontrollera om ett löpar-ID redan är lagrat i en temporär fil. Om inte, använder den curl för att fråga GitHubs API för tillgängliga löpare och jq för att analysera JSON-svaret, välj den första lediga löparen och spara dess ID. Python-skriptet uppnår liknande funktionalitet genom att använda requests.get() metod för att hämta löparinformation från GitHubs API. Skriptet kontrollerar sedan om ett löpar-ID redan är lagrat med os.path.exists() och sparar den om inte.

Båda skripten säkerställer att när en löpare har tilldelats, kommer den att återanvändas för efterföljande jobb genom att referera till det lagrade löpar-ID:t. I Python-skriptet, os.getenv() hämtar miljövariabler för GitHub-token och arkiv, och with open() används för att hantera filoperationer säkert. Dessa skript hjälper till att koordinera flera arbetsflöden, vilket säkerställer att de körs på samma löpare utan att hårdkoda löparnamnet, vilket gör dem flexibla och effektiva när det gäller att hantera arbetsflödesexekveringen.

# 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

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}")

Effektiv löparhantering i GitHub Actions

I scenarier där arbetsflöden måste köras på samma självvärdade löpare, är en viktig faktor att säkerställa löparnas tillgänglighet och minimera konflikter. Genom att använda en delad löparstrategi, som sett i de tidigare skripten, säkerställs att när en löpare har tilldelats ett jobb, använder efterföljande jobb samma löpare. Detta kan vara särskilt fördelaktigt i komplexa CI/CD-pipelines där upprätthållande av tillstånd eller användning av cachade resurser är avgörande.

En annan aspekt att tänka på är att optimera löparanvändningen. Genom att dynamiskt välja och tilldela löpare baserat på tillgänglighet kan organisationer bättre hantera sina resurser. Att implementera sådana strategier förbättrar inte bara effektiviteten utan minskar också den tid som arbetsflöden spenderar i kön och väntar på en ledig löpare. Detta tillvägagångssätt kan utvidgas till andra CI/CD-verktyg och plattformar, vilket gör det till en mångsidig lösning för olika automationsbehov.

Slutsats:

Att hantera GitHub-arbetsflöden så att de körs på samma självhostade löpare är avgörande för effektivitet och konsekvens. De diskuterade Bash- och Python-skripten ger en robust lösning genom att dynamiskt tilldela löpare och säkerställa att efterföljande jobb använder samma löpare. Detta tillvägagångssätt minimerar konflikter och optimerar resursutnyttjandet, vilket gör det till en effektiv strategi för komplexa CI/CD-pipelines. Genom att implementera dessa metoder kan organisationer effektivisera sitt arbetsflöde och minska väntetiderna, vilket i slutändan förbättrar produktiviteten och upprätthåller en smidig utvecklingsprocess.