Création automatique de Pull Requests à chaque Push

L’automatisation de Git peut considérablement rationaliser votre flux de travail de développement. Ce guide explore comment créer automatiquement des pull requests chaque fois que du code est poussé vers votre dépôt, en utilisant divers outils et approches.

Méthode 1 : Utilisation de GitHub Actions (Recommandée)

GitHub Actions fournit un moyen natif et fiable d’automatiser la création de PR. Voici comment le configurer :

Étape 1 : Créer un Workflow GitHub Actions

1. Créez un répertoire .github/workflows/ dans votre dépôt s’il n’existe pas
2. Créez un nouveau fichier appelé auto-pr.yml
3. Ajoutez la configuration suivante :

name: Auto PR on Push

on:
  push:
    branches:
      - 'feature/**'    # Correspond aux branches feature/*
      - 'bugfix/**'     # Correspond aux branches bugfix/*
      # Ajoutez d'autres modèles de branche si nécessaire

jobs:
  create-pull-request:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      pull-requests: write
    
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Requis pour une comparaison correcte des branches

      - name: Create Pull Request
        uses: peter-evans/create-pull-request@v6
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          commit-message: ""PR créée automatiquement depuis ${{ github.ref_name }}""
          title: ""PR automatique : ${{ github.ref_name }}""
          body: |
            Pull request automatisée créée depuis le push vers ${{ github.ref_name }}
            
            Branche : ${{ github.ref_name }}
            Déclenchée par : ${{ github.actor }}
          branch: ${{ github.ref_name }}
          base: main
          labels: |
            automated-pr
            needs-review

Étape 2 : Configurer les paramètres du dépôt

1. Allez dans les paramètres de votre dépôt → Actions → Général
2. Sous ""Autorisations de workflow"", sélectionnez ""Autorisations de lecture et d’écriture""
3. Enregistrez les modifications

Méthode 2 : Utilisation de GitHub CLI

Pour les développeurs préférant l’automatisation locale, GitHub CLI offre une solution simple.

Étape 1 : Installer GitHub CLI

Choisissez votre plateforme :

• macOS : brew install gh
• Ubuntu/Debian : sudo apt install gh
• Windows : winget install GitHub.cli ou téléchargez depuis <https://cli.github.com>
• Autre Linux : Suivez les instructions sur <https://github.com/cli/cli#installation>

Étape 2 : Authentifier GitHub CLI

gh auth login

Étape 3 : Configurer le hook post-push

Créez et configurez le hook post-push :

#!/bin/bash

# Obtenir le nom de la branche actuelle
BRANCH=$(git rev-parse --abbrev-ref HEAD)

# Ne pas créer de PR pour les branches main/master
if [[ ""$BRANCH"" == ""main"" ]] || [[ ""$BRANCH"" == ""master"" ]]; then
    exit 0
fi

# Vérifier si la PR existe déjà
PR_EXISTS=$(gh pr list --head ""$BRANCH"" --json number --jq length)

if [ ""$PR_EXISTS"" -eq 0 ]; then
    # Créer la PR si elle n'existe pas
    gh pr create 
        --base main 
        --head ""$BRANCH"" 
        --title ""PR automatique : $BRANCH"" 
        --body ""Pull request automatisée créée depuis $BRANCH"" 
        --label ""automated-pr""
fi

Méthode 3 : Utilisation des outils CI/CD

Pour les équipes utilisant d’autres plateformes CI/CD, voici comment implémenter l’automatisation des PR en utilisant l’API REST de GitHub.

Exemple de pipeline Jenkins

pipeline {
    agent any
    
    environment {
        GITHUB_TOKEN = credentials('github-token')
    }
    
    stages {
        stage('Create PR') {
            steps {
                script {
                    def branchName = sh(
                        returnStdout: true, 
                        script: 'git rev-parse --abbrev-ref HEAD'
                    ).trim()
                    
                    // Ne pas créer de PR pour main/master
                    if (branchName != 'main' && branchName != 'master') {
                        def response = sh(
                            returnStdout: true,
                            script: """"""
                                curl -X POST 
                                    -H 'Authorization: token ${GITHUB_TOKEN}' 
                                    -H 'Accept: application/vnd.github.v3+json' 
                                    https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}/pulls 
                                    -d '{
                                        ""title"": ""PR automatique : ${branchName}"",
                                        ""head"": ""${branchName}"",
                                        ""base"": ""main"",
                                        ""body"": ""Pull request automatisée créée depuis le pipeline Jenkins""
                                    }'
                            """"""
                        )
                    }
                }
            }
        }
    }
}

Meilleures pratiques et considérations de sécurité

• Activez les règles de protection des branches pour votre branche principale
• Créez des modèles de PR standardisés
• Utilisez des labels pour distinguer les PR automatisées
• Configurez l’assignation automatique des relecteurs
• Stockez les tokens de manière sécurisée en utilisant les secrets du dépôt
• Limitez les autorisations des tokens aux portées requises
• Faites tourner régulièrement les tokens d’authentification
• Examinez les paramètres des PR automatisées pour éviter l’exposition de données sensibles

Conclusion

L’automatisation de la création des pull requests peut améliorer considérablement votre flux de travail de développement en assurant des processus de revue de code cohérents et en réduisant l’effort manuel. Que vous choisissiez GitHub Actions, GitHub CLI ou des outils CI/CD, la mise en œuvre de ces techniques d’automatisation vous aidera à rationaliser votre processus de développement et à maintenir un meilleur contrôle de la qualité du code.

FAQs