Guide: Kørsel af Git-arbejdsgange på samme løber

Koordinering af GitHub-arbejdsgange på delte løbere

Det kan være udfordrende at administrere flere arbejdsgange i GitHub Actions, især når du har brug for dem til at køre på den samme selv-hostede løber. I scenarier, hvor du har separate YAML-filer til forskellige arbejdsgange, såsom codeql.yml og snyk-zap.yml, kan det være vanskeligt at sikre, at de kører på den samme runner fra en bestemt gruppe.

Målet er at bruge den samme løber til begge arbejdsgange uden eksplicit at navngive løberen, og derved undgå konflikter med andre arbejdsgange. Denne vejledning vil udforske mulige løsninger for at opnå denne synkronisering effektivt og samtidig opretholde arbejdsgangene i separate YAML-filer.

Koordinering af arbejdsgange med delte løbere

De medfølgende scripts administrerer runner-tildeling for GitHub-arbejdsgange. Bash-scriptet starter med at kontrollere, om et runner-id allerede er gemt i en midlertidig fil. Hvis ikke, bruger den curl at forespørge GitHub's API for tilgængelige løbere og jq for at analysere JSON-svaret, vælge den første ledige løber og gemme dens ID. Python-scriptet opnår lignende funktionalitet ved at bruge requests.get() metode til at hente løberinformation fra GitHubs API. Scriptet kontrollerer derefter, om et runner-id allerede er gemt ved hjælp af os.path.exists() og gemmer den hvis ikke.

Begge scripts sikrer, at når en runner er tildelt, vil den blive genbrugt til efterfølgende job ved at referere til det gemte runner ID. I Python-scriptet, os.getenv() henter miljøvariabler til GitHub-tokenet og repository, og with open() bruges til at håndtere filoperationer sikkert. Disse scripts hjælper med at koordinere flere arbejdsgange og sikrer, at de kører på den samme runner uden hardkodning af løberens navn, hvilket gør dem fleksible og effektive til at styre udførelse af workflow.

# 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 Runner Management i GitHub Actions

I scenarier, hvor arbejdsgange skal køre på den samme selv-hostede løber, er en vigtig overvejelse at sikre løberens tilgængelighed og minimere konflikter. Brug af en delt runner-strategi, som set i de tidligere scripts, sikrer, at når en løber er tildelt et job, bruger efterfølgende job den samme runner. Dette kan være særligt fordelagtigt i komplekse CI/CD-pipelines, hvor opretholdelse af tilstand eller brug af cachelagrede ressourcer er afgørende.

Et andet aspekt at overveje er at optimere løberudnyttelsen. Ved dynamisk at vælge og tildele løbere baseret på tilgængelighed kan organisationer bedre administrere deres ressourcer. Implementering af sådanne strategier forbedrer ikke kun effektiviteten, men reducerer også den tid, arbejdsgange bruger i køen og venter på en ledig løber. Denne tilgang kan udvides til andre CI/CD værktøjer og platforme, hvilket gør den til en alsidig løsning til forskellige automatiseringsbehov.

Konklusion:

At administrere GitHub-arbejdsgange til at køre på den samme selv-hostede løber er afgørende for effektivitet og konsistens. De diskuterede Bash- og Python-scripts giver en robust løsning ved dynamisk at tildele løbere og sikre, at efterfølgende job bruger den samme løber. Denne tilgang minimerer konflikter og optimerer ressourceudnyttelsen, hvilket gør den til en effektiv strategi for komplekse CI/CD-pipelines. Ved at implementere disse metoder kan organisationer strømline deres arbejdsgange og reducere ventetider, hvilket i sidste ende forbedrer produktiviteten og opretholder en smidig udviklingsproces.