Guía: Ejecutar flujos de trabajo de Git en el mismo ejecutor

Coordinación de flujos de trabajo de GitHub en corredores compartidos

Administrar múltiples flujos de trabajo en GitHub Actions puede ser un desafío, especialmente cuando necesitas que se ejecuten en el mismo ejecutor autohospedado. En escenarios en los que tiene archivos YAML separados para diferentes flujos de trabajo, como codeql.yml y snyk-zap.yml, garantizar que se ejecuten en el mismo ejecutor de un grupo específico puede resultar complicado.

El objetivo es utilizar el mismo ejecutor para ambos flujos de trabajo sin nombrarlo explícitamente, evitando así conflictos con otros flujos de trabajo. Esta guía explorará posibles soluciones para lograr esta sincronización de manera eficiente mientras se mantienen los flujos de trabajo en archivos YAML separados.

Coordinación de flujos de trabajo con ejecutores compartidos

Los scripts proporcionados administran la asignación de ejecutores para los flujos de trabajo de GitHub. El script Bash comienza verificando si una ID de corredor ya está almacenada en un archivo temporal. Si no, usa curl para consultar la API de GitHub para los corredores disponibles y jq para analizar la respuesta JSON, seleccionando el primer corredor inactivo y guardando su ID. El script Python logra una funcionalidad similar utilizando el requests.get() método para obtener información del corredor de la API de GitHub. Luego, el script verifica si una ID de corredor ya está almacenada usando os.path.exists() y lo guarda si no.

Ambos scripts garantizan que una vez que se asigna un ejecutor, se reutilizará para trabajos posteriores haciendo referencia al ID del ejecutor almacenado. En el script de Python, os.getenv() recupera variables de entorno para el token y el repositorio de GitHub, y with open() se utiliza para manejar operaciones de archivos de forma segura. Estos scripts ayudan a coordinar múltiples flujos de trabajo, garantizando que se ejecuten en el mismo ejecutor sin codificar el nombre del ejecutor, lo que los hace flexibles y eficientes en la gestión de la ejecución del flujo de trabajo.

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

Gestión eficiente de corredores en GitHub Actions

En escenarios en los que los flujos de trabajo deben ejecutarse en el mismo ejecutor autohospedado, una consideración clave es garantizar la disponibilidad del ejecutor y minimizar los conflictos. El uso de una estrategia de ejecutor compartido, como se vio en los scripts anteriores, garantiza que una vez que se asigna un ejecutor a un trabajo, los trabajos posteriores utilicen el mismo ejecutor. Esto puede ser particularmente beneficioso en procesos complejos de CI/CD donde mantener el estado o utilizar recursos almacenados en caché es crucial.

Otro aspecto a considerar es la optimización del aprovechamiento de los corredores. Al seleccionar y asignar dinámicamente corredores según la disponibilidad, las organizaciones pueden administrar mejor sus recursos. La implementación de tales estrategias no solo mejora la eficiencia sino que también reduce el tiempo que los flujos de trabajo pasan en la cola, esperando a un corredor disponible. Este enfoque se puede extender a otras herramientas y plataformas de CI/CD, lo que lo convierte en una solución versátil para diversas necesidades de automatización.

Conclusión:

Administrar los flujos de trabajo de GitHub para que se ejecuten en el mismo ejecutor autohospedado es crucial para lograr eficiencia y coherencia. Los scripts de Bash y Python analizados proporcionan una solución sólida al asignar dinámicamente ejecutores y garantizar que los trabajos posteriores utilicen el mismo ejecutor. Este enfoque minimiza los conflictos y optimiza la utilización de recursos, lo que lo convierte en una estrategia eficaz para procesos complejos de CI/CD. Al implementar estos métodos, las organizaciones pueden optimizar la ejecución de su flujo de trabajo y reducir los tiempos de espera, lo que en última instancia mejora la productividad y mantiene un proceso de desarrollo fluido.