Utilitzeu conjunts de regles i regles de protecció de branques amb PyGithub per habilitar la cua de combinació de GitHub

Agilitzar els processos de combinació amb GitHub: una guia per habilitar les cues de combinació

A mesura que els equips de desenvolupament de programari creixen, també ho fa la complexitat dels seus fluxos de treball Git. Gestionar diversos dipòsits, gestionar les sol·licituds d'extracció i garantir una integració fluida pot ser un repte. Un dels avenços recents que pretén resoldre aquests problemes és la Cua de combinació de GitHub. Aquesta característica us permet automatitzar el procés de combinació de sol·licituds d'extracció d'una manera controlada i previsible, assegurant que el codi estigui sempre actualitzat sense causar conflictes. 🚀

Tanmateix, habilitar i configurar la Cua de combinació no és tan senzill com girar un interruptor. Requereix l'ús de l'API de GitHub GraphQL, específicament mitjançant conjunts de regles per a una configuració adequada. Els desenvolupadors, com jo, sovint es troben amb reptes quan intenten implementar aquestes funcions a escala, especialment quan gestionen centenars de dipòsits. Recordo que vaig aprofundir en les discussions de GitHub i vaig ensopegar amb explicacions útils però encara complexes sobre les cues de combinació. Però el veritable truc és entendre com escriure la mutació GraphQL correcta per habilitar aquesta funció de manera eficaç. 🤔

La meva primera experiència amb regles de protecció de branques va ser una mica com un trencaclosques. Vaig poder protegir les branques amb èxit mitjançant GraphQL, però la configuració de la funcionalitat de la cua de combinació requeria un enfocament més específic. L'objectiu d'aquesta guia és explicar-vos com habilitar la cua de combinació als vostres dipòsits, abordant alguns obstacles comuns al llarg del camí i explicant com PyGithub pot jugar un paper clau en la simplificació d'aquestes tasques. No es tracta només d'afegir regles, es tracta de fer-les treballar junts sense problemes. 💻

En aquesta publicació, explorarem el procés d'habilitació de la Cua de combinació mitjançant les API i els conjunts de regles de GraphQL. Veureu com automatitzar les regles de protecció de sucursals amb trucades d'API i, fins i tot si teniu problemes amb mutacions, aquesta guia us proporcionarà claredat. A més, parlarem d'alternatives per configurar aquesta funció, sobretot si busqueu un enfocament més pràctic amb PyGithub en lloc de treballar directament amb GraphQL. Amb exemples pràctics i alguns consells de resolució de problemes, volem fer que la vostra experiència de GitHub sigui més eficient. 🔧

Com funciona el guió i per a què serveix

En aquest script, l'objectiu és utilitzar l'API GraphQL de GitHub per configurar regles de protecció de branques per a un repositori. El procés comença enviant una sol·licitud a l'API de GitHub per obtenir l'ID del repositori mitjançant una consulta GraphQL. Això és essencial perquè l'identificador és necessari per aplicar qualsevol canvi, com ara la protecció de branques o l'habilitació de cues de combinació. A la funció `get_repository_id()`, es fa una sol·licitud amb el nom i el propietari del repositori, recuperant l'ID únic del repositori. L'API respon amb aquest ID, la qual cosa ens permet continuar amb la creació de les regles de protecció.

El següent pas consisteix a utilitzar l'ID del dipòsit per aplicar les regles de protecció de branques. La funció `create_branch_protection_rule()` crea una mutació GraphQL per establir la protecció per a una branca. En aquest cas, la branca que s'ha de protegir està definida per la variable `BRANCH_PATTERN`, i les regles de protecció inclouen requisits com l'aprovació de revisions, la verificació de l'estat i l'aplicació de permisos d'administrador. Aquests paràmetres es personalitzen en funció de les necessitats del dipòsit, com ara garantir que només les compilacions que passen es puguin combinar o fer complir fluxos de treball d'aprovació estrictes.

Un cop definida la mutació, l'script envia una sol·licitud a l'API GraphQL de GitHub mitjançant el mètode `requests.post`. Això envia una sol·licitud POST amb la consulta de mutació i els paràmetres rellevants. Si la sol·licitud té èxit, l'API retorna els detalls de la regla de protecció que s'ha creat. El `response.status_code` es verifica per assegurar-se que l'operació ha tingut èxit, i si es produeix algun error, es genera una excepció. Aquest mecanisme ajuda a garantir que si alguna cosa va malament, l'script pot alertar l'usuari amb un missatge d'error útil.

Finalment, l'script està dissenyat per ser modular i reutilitzable per a diversos dipòsits. Podeu escalar-ho fàcilment fins a 100s de dipòsits ajustant els paràmetres com ara "REPOSITORY_OWNER" i "REPOSITORY_NAME". Si necessiteu aplicar les mateixes regles de protecció a diversos dipòsits, l'script permet flexibilitat simplement canviant els valors d'entrada. A més, l'script està construït de manera que es pugui integrar fàcilment en fluxos de treball d'automatització més grans, com ara pipelines CI/CD, on protegir les branques o habilitar una cua de combinació és crucial per mantenir la qualitat del codi coherent en diversos projectes. 🚀

import requests
GITHUB_API_URL = 'https://api.github.com/graphql'
TOKEN = 'your_token_here'
headers = {
    "Authorization": f"Bearer {TOKEN}",
    "Content-Type": "application/json"
}
# Repository and Branch details
REPOSITORY_OWNER = "your_owner_name"
REPOSITORY_NAME = "your_repo_name"
BRANCH_PATTERN = "main"
# GraphQL mutation for creating a merge queue rule
mutation = """
mutation($repositoryId: ID!, $branchPattern: String!) {
  createMergeQueueRule(input: {
    repositoryId: $repositoryId,
    pattern: $branchPattern,
    requiresStatusChecks: true,
    allowsMergeQueue: true,
  }) {
    mergeQueueRule {
      id
      pattern
      requiresStatusChecks
      allowsMergeQueue
    }
  }
}"""
# Query to fetch repository ID
repository_query = """
query($owner: String!, $name: String!) {
  repository(owner: $owner, name: $name) {
    id
  }
}"""
def get_repository_id():
    variables = {"owner": REPOSITORY_OWNER, "name": REPOSITORY_NAME}
    response = requests.post(
        GITHUB_API_URL,
        json={"query": repository_query, "variables": variables},
        headers=headers
    )
    if response.status_code == 200:
        return response.json()["data"]["repository"]["id"]
    else:
        raise Exception(f"Failed to fetch repository ID: {response.json()}")
def enable_merge_queue(repository_id):
    variables = {
        "repositoryId": repository_id,
        "branchPattern": BRANCH_PATTERN,
    }
    response = requests.post(
        GITHUB_API_URL,
        json={"query": mutation, "variables": variables},
        headers=headers
    )
    if response.status_code == 200:
        print("Merge queue rule created:", response.json()["data"]["createMergeQueueRule"]["mergeQueueRule"])
    else:
        raise Exception(f"Failed to create merge queue rule: {response.json()}")
# Execute
try:
    repository_id = get_repository_id()
    enable_merge_queue(repository_id)
except Exception as e:
    print("Error:", e)

from github import Github
import os
# GitHub access token and repository details
GITHUB_TOKEN = os.getenv('GITHUB_TOKEN')
g = Github(GITHUB_TOKEN)
# Define the repository and branch pattern
repo_name = "your_repo_name"
branch_name = "main"
# Get the repository object
repo = g.get_repo(repo_name)
# Fetch the branch protection rule
branch = repo.get_branch(branch_name)
protection = branch.get_protection()
# Update branch protection to enable merge queue
protection.update(
    required_status_checks={"strict": True, "contexts": []},
    enforce_admins=True,
    allow_force_pushes=False,
    dismiss_stale_reviews=True,
    required_pull_request_reviews={"dismissal_restrictions": {}, "require_code_owner_reviews": True},
    merge_queue_enabled=True
)
# Display status
print(f"Merge queue enabled for branch {branch_name}")

Habilitació de la cua de combinació amb l'API i els conjunts de regles GraphQL de GitHub

Quan es gestionen grans dipòsits, especialment entre diversos equips i projectes, és crucial implementar una cua de fusió per agilitzar el procés de fusió. D'aquesta manera s'assegura que els canvis realitzats a les diferents branques són revisats, provats i integrats sense provocar conflictes ni trencar la branca principal. La cua de combinació de GitHub és una solució excel·lent, ja que automatitza el procés de combinació de sol·licituds d'extracció d'una manera segura i ordenada, especialment quan es tracta de centenars de dipòsits. A diferència de les regles tradicionals de protecció de sucursals, que imposen comprovacions com les revisions necessàries i les comprovacions d'estat, la cua de combinació permet una fusió controlada i seqüencial de les sol·licituds d'extracció, assegurant un pipeline CI/CD més fluid.

Tanmateix, habilitar aquesta funció per a diversos dipòsits requereix una comprensió sòlida de l' API GraphQL de GitHub, que facilita un control més granular sobre la configuració del dipòsit, inclosa l'habilitació de la cua de combinació. Tot i que el procés per crear regles de protecció de branques és relativament senzill amb mutacions GraphQL, la inclusió de la funcionalitat de la cua de combinació requereix una immersió més profunda en els conjunts de regles. Els conjunts de regles són essencialment una eina de configuració dins de l'API GraphQL de GitHub que us permeten aplicar condicions complexes per a la fusió de sol·licituds d'extracció, inclosa la cua automàtica de PR en funció dels criteris que definiu.

En integrar conjunts de regles amb la funcionalitat de la cua de combinació, podeu assegurar-vos que totes les sol·licituds d'extracció es gestionen de manera ordenada, evitant possibles colls d'ampolla o errors en el procés d'integració. Aquesta funcionalitat es pot implementar en diversos dipòsits escrivint scripts reutilitzables que interactuen amb l'API GraphQL de GitHub, cosa que us permet automatitzar l'aplicació d'aquesta configuració per a centenars de dipòsits de la vostra organització. La clau per habilitar amb èxit la cua de combinació rau a utilitzar correctament les mutacions de l'API, assegurar-se que la cua de combinació estigui activada i gestionar diversos casos extrems que puguin sorgir durant el procés de combinació. 🚀