Guide : Exécuter des workflows Git sur le même exécuteur

Coordonner les flux de travail GitHub sur les coureurs partagés

La gestion de plusieurs flux de travail dans GitHub Actions peut s'avérer difficile, en particulier lorsque vous avez besoin de les exécuter sur le même exécuteur auto-hébergé. Dans les scénarios où vous disposez de fichiers YAML distincts pour différents flux de travail, comme codeql.yml et snyk-zap.yml, il peut être délicat de s'assurer qu'ils s'exécutent sur le même exécuteur à partir d'un groupe spécifique.

L'objectif est d'utiliser le même exécuteur pour les deux flux de travail sans nommer explicitement le coureur, évitant ainsi les conflits avec d'autres flux de travail. Ce guide explorera les solutions possibles pour réaliser cette synchronisation efficacement tout en conservant les flux de travail dans des fichiers YAML séparés.

Coordination des flux de travail avec les coureurs partagés

Les scripts fournis gèrent l'affectation des coureurs pour les workflows GitHub. Le script Bash commence par vérifier si un ID de coureur est déjà stocké dans un fichier temporaire. Sinon, il utilise curl pour interroger l'API de GitHub pour les coureurs disponibles et jq pour analyser la réponse JSON, en sélectionnant le premier exécuteur inactif et en enregistrant son ID. Le script Python obtient des fonctionnalités similaires en utilisant le requests.get() méthode pour récupérer les informations du coureur à partir de l’API de GitHub. Le script vérifie ensuite si un identifiant de coureur est déjà stocké en utilisant os.path.exists() et l'enregistre sinon.

Les deux scripts garantissent qu'une fois qu'un coureur est attribué, il sera réutilisé pour les tâches suivantes en faisant référence à l'ID de coureur stocké. Dans le script Python, os.getenv() récupère les variables d'environnement pour le jeton et le référentiel GitHub, et with open() est utilisé pour gérer les opérations sur les fichiers en toute sécurité. Ces scripts aident à coordonner plusieurs flux de travail, garantissant qu'ils s'exécutent sur le même exécuteur sans coder en dur le nom du coureur, ce qui les rend flexibles et efficaces dans la gestion de l'exécution du flux de travail.

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

Gestion efficace des coureurs dans les actions GitHub

Dans les scénarios où les flux de travail doivent s’exécuter sur le même exécuteur auto-hébergé, il est essentiel de veiller à la disponibilité des exécuteurs et de minimiser les conflits. L'utilisation d'une stratégie d'exécution partagée, comme vue dans les scripts précédents, garantit qu'une fois qu'un exécuteur est affecté à une tâche, les tâches suivantes utilisent le même exécuteur. Cela peut être particulièrement bénéfique dans les pipelines CI/CD complexes où le maintien de l'état ou l'utilisation des ressources mises en cache sont cruciales.

Un autre aspect à considérer est l’optimisation de l’utilisation des coureurs. En sélectionnant et en affectant dynamiquement les coureurs en fonction de la disponibilité, les organisations peuvent mieux gérer leurs ressources. La mise en œuvre de telles stratégies améliore non seulement l'efficacité, mais réduit également le temps passé par les flux de travail dans la file d'attente, en attente d'un coureur disponible. Cette approche peut être étendue à d'autres outils et plates-formes CI/CD, ce qui en fait une solution polyvalente pour divers besoins d'automatisation.

Conclusion:

La gestion des workflows GitHub pour qu'ils s'exécutent sur le même exécuteur auto-hébergé est cruciale pour l'efficacité et la cohérence. Les scripts Bash et Python discutés fournissent une solution robuste en attribuant dynamiquement des exécuteurs et en garantissant que les tâches ultérieures utilisent le même exécuteur. Cette approche minimise les conflits et optimise l'utilisation des ressources, ce qui en fait une stratégie efficace pour les pipelines CI/CD complexes. En mettant en œuvre ces méthodes, les organisations peuvent rationaliser l'exécution de leur flux de travail et réduire les temps d'attente, améliorant ainsi la productivité et maintenant un processus de développement fluide.