Guia: executando fluxos de trabalho Git no mesmo executor

Coordenando fluxos de trabalho do GitHub em executores compartilhados

Gerenciar vários fluxos de trabalho no GitHub Actions pode ser desafiador, especialmente quando você precisa que eles sejam executados no mesmo executor auto-hospedado. Em cenários em que você tem arquivos YAML separados para fluxos de trabalho diferentes, como codeql.yml e snyk-zap.yml, pode ser complicado garantir que eles sejam executados no mesmo executor de um grupo específico.

O objetivo é utilizar o mesmo executor para ambos os fluxos de trabalho sem nomear explicitamente o executor, evitando assim conflitos com outros fluxos de trabalho. Este guia explorará possíveis soluções para obter essa sincronização de forma eficiente, mantendo os fluxos de trabalho em arquivos YAML separados.

Coordenando fluxos de trabalho com executores compartilhados

Os scripts fornecidos gerenciam a atribuição do executor para fluxos de trabalho do GitHub. O script Bash começa verificando se um ID do executor já está armazenado em um arquivo temporário. Se não, ele usa curl para consultar a API do GitHub para executores disponíveis e jq para analisar a resposta JSON, selecionando o primeiro executor ocioso e salvando seu ID. O script Python alcança funcionalidade semelhante utilizando o requests.get() método para buscar informações do corredor da API do GitHub. O script então verifica se um ID do executor já está armazenado usando os.path.exists() e salva se não.

Ambos os scripts garantem que, uma vez atribuído um executor, ele será reutilizado em trabalhos subsequentes, referenciando o ID do executor armazenado. No script Python, os.getenv() recupera variáveis ​​de ambiente para o token e repositório GitHub e with open() é usado para lidar com operações de arquivo com segurança. Esses scripts ajudam a coordenar vários fluxos de trabalho, garantindo que sejam executados no mesmo executor sem codificar o nome do executor, tornando-os flexíveis e eficientes no gerenciamento da execução do fluxo de trabalho.

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

Gerenciamento eficiente de executores em ações do GitHub

Em cenários em que os fluxos de trabalho precisam ser executados no mesmo executor auto-hospedado, uma consideração importante é garantir a disponibilidade do executor e minimizar conflitos. Usar uma estratégia de executor compartilhado, como visto nos scripts anteriores, garante que, uma vez atribuído um executor a uma tarefa, as tarefas subsequentes usem o mesmo executor. Isso pode ser particularmente benéfico em pipelines complexos de CI/CD, onde a manutenção do estado ou a utilização de recursos em cache é crucial.

Outro aspecto a considerar é otimizar a utilização do corredor. Ao selecionar e atribuir dinamicamente executores com base na disponibilidade, as organizações podem gerenciar melhor seus recursos. A implementação de tais estratégias não só melhora a eficiência, mas também reduz o tempo que os fluxos de trabalho passam na fila, esperando por um corredor disponível. Essa abordagem pode ser estendida a outras ferramentas e plataformas de CI/CD, tornando-a uma solução versátil para diversas necessidades de automação.

Conclusão:

Gerenciar fluxos de trabalho do GitHub para execução no mesmo executor auto-hospedado é crucial para eficiência e consistência. Os scripts Bash e Python discutidos fornecem uma solução robusta ao atribuir executores dinamicamente e garantir que os trabalhos subsequentes usem o mesmo executor. Essa abordagem minimiza conflitos e otimiza a utilização de recursos, tornando-a uma estratégia eficaz para pipelines complexos de CI/CD. Ao implementar esses métodos, as organizações podem agilizar a execução do fluxo de trabalho e reduzir os tempos de espera, melhorando a produtividade e mantendo um processo de desenvolvimento tranquilo.