Gids: Git-workflows uitvoeren op dezelfde Runner

GitHub-workflows coördineren op gedeelde runners

Het beheren van meerdere workflows in GitHub Actions kan een uitdaging zijn, vooral als je ze nodig hebt om op dezelfde zelf-gehoste runner te draaien. In scenario's waarin je afzonderlijke YAML-bestanden hebt voor verschillende workflows, zoals codeql.yml en snyk-zap.yml, kan het lastig zijn om ervoor te zorgen dat ze op dezelfde runner uit een specifieke groep draaien.

Het doel is om dezelfde runner voor beide workflows te gebruiken zonder de runner expliciet te noemen, waardoor conflicten met andere workflows worden vermeden. In deze handleiding worden mogelijke oplossingen onderzocht om deze synchronisatie efficiënt te realiseren, terwijl de workflows in afzonderlijke YAML-bestanden behouden blijven.

Commando	Beschrijving
jq	Een lichtgewicht en flexibele JSON-opdrachtregelprocessor die wordt gebruikt om JSON-uitvoer in het Bash-script te parseren.
head -n 1	Voert de eerste regel van het resultaat uit, die hier wordt gebruikt om de eerste beschikbare hardloper-ID te selecteren.
curl	Commandoregeltool voor het overbrengen van gegevens met URL's, gebruikt om te communiceren met de API van GitHub in het Bash-script.
os.getenv()	Haalt omgevingsvariabelen op in Python, gebruikt om het GitHub-token en de naam van de repository op te halen.
requests.get()	Stuurt een GET-verzoek naar een opgegeven URL, die wordt gebruikt om beschikbare runners op te halen uit de GitHub-API in het Python-script.
os.path.exists()	Controleert of een opgegeven pad bestaat, gebruikt om te bepalen of het runner-ID-bestand al aanwezig is in het Python-script.
with open()	Contextmanager voor bestandsbewerkingen in Python, gebruikt om de runner-ID naar een bestand te lezen en te schrijven.

Workflows coördineren met gedeelde hardlopers

De meegeleverde scripts beheren runnertoewijzingen voor GitHub-workflows. Het Bash-script begint met het controleren of er al een runner-ID in een tijdelijk bestand is opgeslagen. Zo niet, dan wordt er gebruik van gemaakt om de API van GitHub op te vragen voor beschikbare hardlopers en om het JSON-antwoord te parseren, de eerste inactieve runner te selecteren en de ID ervan op te slaan. Het Python-script bereikt vergelijkbare functionaliteit door gebruik te maken van de methode om runner-informatie op te halen uit de API van GitHub. Het script controleert vervolgens of er al een runner-ID is opgeslagen met behulp van os.path.exists() en bewaart het als dat niet het geval is.

Beide scripts zorgen ervoor dat zodra een hardloper is toegewezen, deze voor volgende taken wordt hergebruikt door te verwijzen naar de opgeslagen hardloper-ID. In het Python-script, haalt omgevingsvariabelen op voor het GitHub-token en de repository, en wordt gebruikt om bestandsbewerkingen veilig af te handelen. Deze scripts helpen bij het coördineren van meerdere workflows, zodat ze op dezelfde runner draaien zonder de hardlopernaam hard te coderen, waardoor ze flexibel en efficiënt zijn bij het beheren van de workflow-uitvoering.

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

Efficiënt runnerbeheer in GitHub-acties

In scenario's waarin workflows op dezelfde zelf-hostende runner moeten worden uitgevoerd, is het garanderen van de beschikbaarheid van runners en het minimaliseren van conflicten een belangrijke overweging. Het gebruik van een gedeelde hardloperstrategie, zoals te zien in de vorige scripts, zorgt ervoor dat zodra een hardloper aan een taak is toegewezen, volgende taken dezelfde hardloper gebruiken. Dit kan met name nuttig zijn in complexe CI/CD-pijplijnen waarbij het behouden van de status of het gebruik van in de cache opgeslagen bronnen van cruciaal belang is.

Een ander aspect waarmee rekening moet worden gehouden, is het optimaliseren van de benutting van hardlopers. Door hardlopers dynamisch te selecteren en toe te wijzen op basis van beschikbaarheid, kunnen organisaties hun middelen beter beheren. Het implementeren van dergelijke strategieën verbetert niet alleen de efficiëntie, maar vermindert ook de tijd die workflows in de wachtrij doorbrengen, wachtend op een beschikbare runner. Deze aanpak kan worden uitgebreid naar andere CI/CD-tools en -platforms, waardoor het een veelzijdige oplossing wordt voor verschillende automatiseringsbehoeften.

1. Hoe zorg ik ervoor dat er altijd een specifieke hardloper wordt gebruikt?
2. Gebruik de toets uw YAML-bestand in om de hardlopergroep of de exacte hardlopernaam op te geven.
3. Kan ik hardlopers dynamisch toewijzen aan workflows?
4. Ja, door scripts te gebruiken om beschikbare lopers op te vragen en deze dynamisch toe te wijzen.
5. Hoe ga ik om met hardloperconflicten in een drukke omgeving?
6. Implementeer een wachtrijmechanisme of geef prioriteit aan workflows om de toewijzing van runners effectief te beheren.
7. Wat gebeurt er als er geen lopers beschikbaar zijn?
8. Workflows staan ​​in de wachtrij totdat er een runner beschikbaar komt. Optimaliseer het gebruik van runners om wachttijden te minimaliseren.
9. Kan ik deze scripts gebruiken met andere CI/CD-platforms?
10. Ja, de logica kan worden aangepast voor andere platforms met API-toegang tot runnerbeheer.
11. Hoe onderhoud ik de status tussen workflows?
12. Zorg ervoor dat dezelfde runner wordt gebruikt voor gerelateerde taken en maak waar mogelijk gebruik van caching-mechanismen.
13. Welke machtigingen zijn vereist voor deze scripts?
14. Zorg ervoor dat uw GitHub-token het benodigde bereik heeft, zoals En .
15. Kan ik meerdere workflows tegelijkertijd uitvoeren op dezelfde runner?
16. Normaal gesproken niet. Elke loper voert één taak tegelijk uit. Gebruik meerdere runners voor gelijktijdigheid.
17. Hoe houd ik het gebruik en de prestaties van hardlopers in de gaten?
18. Gebruik de ingebouwde monitoringtools of externe services van GitHub om de activiteiten en prestaties van hardlopers bij te houden.

Conclusie:

Het beheren van GitHub-workflows zodat deze op dezelfde zelfgehoste runner kunnen worden uitgevoerd, is cruciaal voor efficiëntie en consistentie. De besproken Bash- en Python-scripts bieden een robuuste oplossing door lopers dynamisch toe te wijzen en ervoor te zorgen dat volgende taken dezelfde loper gebruiken. Deze aanpak minimaliseert conflicten en optimaliseert het gebruik van resources, waardoor het een effectieve strategie is voor complexe CI/CD-pijplijnen. Door deze methoden te implementeren kunnen organisaties de uitvoering van hun workflow stroomlijnen en wachttijden verkorten, waardoor uiteindelijk de productiviteit wordt verbeterd en een soepel ontwikkelingsproces wordt gehandhaafd.