Gestion des demandes de fusion d’urgence à l’aide de files d’attente de fusion

Gestion des demandes de pull d’urgence a été un sujet de débat dans la communauté des développeurs depuis l’avènement des pratiques Agile et DevOps.

Dans de telles situations, nous avons besoin d’un système qui puisse prioriser ces ‘demandes urgentes’ sur les PR réguliers et nous permette de reporter certains contrôles CI si nécessaire.

Une bonne stratégie peut être de mettre en place une file d’attente de fusion distincte, qui nous permet d’anticiper la file d’attente par défaut même avant que les tests CI ne soient passés et d’accélérer nos corrections urgentes en production.

Dans cet article, nous allons créer deux files d’attente de fusion avec Mergify déclenchées par des étiquettes de PR. Nous allons configurer une pour les PR réguliers et l’autre pour gérer les PR d’urgence.

Alors, enroulons nos manches et commençons!

Pour cette démo, nous allons initialiser une simple application React. Et pour le CI, nous utiliserons CircleCI.

Nous allons créer deux files d’attente:

• default: Tous les PR passeront par elle régulièrement. Elle nécessite des contrôles CircleCI avant de procéder.
• urgent: Cette file d’attente est uniquement pour les PR qui ont l’étiquette urgent dans le PR. Cela permet aux PR de passer au premier plan des PR dans la file d’attente default sans exécuter les contrôles CircleCI.

Avec une telle configuration, une pull request avec l’étiquette urgent entrera dans la file d’attente avant même que le CI ne s’exécute.

Elle sera en tête de la file d’attente par défaut. Mergify mettra à jour la pull request avec sa branche de base si nécessaire, attendra que le CI passe, puis fusionnera la pull request.

Également du point de vue de l’équipe de développement, c’est un processus assez simple. Le développeur doit simplement ajouter une étiquette urgent lors de la création de la PR pour accélérer le processus.

Configuration de Notre Projet

Commençons par configurer notre projet. Nous allons créer une nouvelle application React en utilisant create-react-app.

mkdir emergency-pr-demo
cd emergency-pr-demo
git init
npx create-react-app .

À titre de référence, voici la structure finale de notre projet après avoir ajouté notre configuration CI et Mergify.

emergency-pr-demo/
├── .circleci
│   └── config.yml
├── README.md
├── package-lock.json
├── package.json
├── .gitignore
├── .mergify.yml
├── .vscode
├── public
│   ├── favicon.ico
│   ├── index.html
│   ├── logo192.png
│   ├── logo512.png
│   ├── manifest.json
│   └── robots.txt
└── src
    ├── App.css
    ├── App.js
    ├── App.test.js
    ├── index.css
    ├── index.js
    ├── logo.svg
    ├── reportWebVitals.js
    └── setupTests.js

Création de la Configuration CI

Pour exécuter nos tests, nous utiliserons CircleCI. Il est facile à configurer et à démarrer.

Ici, nous créerons un fichier config.yml dans un nouveau répertoire .circleci à la racine de notre projet.

Nous créerons un job simple build_and_test qui nous aidera d’abord à vérifier si notre projet est construit comme prévu, puis exécutera les tests unitaires avec la commande npm run test.

version: 2.1
orbs:
  node: circleci/[email protected]

jobs:
  build_and_test:
    executor: node/default
    steps:
      - checkout
      - node/install-packages:
          pkg-manager: npm
      - run:
          command: npm run test
          name: Run tests
      - run:
          command: npm run build
          name: Build app
      - persist_to_workspace:
          root: ~/project
          paths:
            - .

workflows:
  test_my_app:
    jobs:
      - build_and_test

Création de la Configuration Mergify

Il est maintenant temps de créer notre fichier de configuration Mergify.

Mergify est un outil qui automatise le processus de fusion des demandes de tirage dans les dépôts de code en fonction de règles et de conditions prédéfinies.

Nous devons définir deux files d’attente dans notre fichier de configuration comme prévu : urgent et default.

Les deux ont les mêmes merge_conditions, check-success=ci/circleci: build_and_test, ce qui signifie que le code doit réussir avec succès le contrôle build_and_test dans CircleCI avant de pouvoir être fusionné.

La section pull_request_rules détaille comment les demandes de pull doivent être gérées. Nous placerons notre PR dans la file d’attente urgent s’il a l’étiquette urgent. Sinon, il entrera dans la file d’attente par défaut.

.mergify.yml

queue_rules:
  - name: urgent
    merge_conditions:
      - "check-success=ci/circleci: build_and_test"

  - name: default
    merge_conditions:
      - "check-success=ci/circleci: build_and_test"

pull_request_rules:
  - name: move to urgent queue when label urgent
    conditions:
      - base=main
      - label=urgent
    actions:
      queue:
        name: urgent

  - name: merge using the default queue after running the CI checks
    conditions:
      - base=main
      - "check-success=ci/circleci: build_and_test"
      - label!=urgent
    actions:
      queue:
        name: default

Configuration du dépôt

Non, nous allons plutôt créer un nouveau dépôt sur GitHub. 

Après cela, nous devons faire un premier commit et pousser notre code en utilisant les commandes suivantes:

git add .
git commit -m "Initial commit"
git remote add origin <REPO_URL>
git push -u origin master

Ensuite, nous devons configurer CircleCI. Pour cela, nous visiterons le Tableau de bord CircleCI, puis aller dans la section projets et configurer notre projet.

Nous devons également spécifier notre branche main. CircleCI détectera automatiquement notre fichier config dans ce cas.

Nous pouvons installer Mergify sur notre compte GitHub en visitant dashboard.mergify.com ou github.com/apps/mergify/installations/new et en nous connectant avec notre compte GitHub.

Ensuite, nous pourrions sélectionner les dépôts auxquels nous voulons donner accès à Mergify.

Une fois configuré, nous pourrions voir nos deux files d’attente dans le Tableau de bord Mergify. 

Ouverture du premier PR (PR régulier)

Commençons par créer notre premier PR. Nous créerions d’abord une nouvelle branche regular-pr

git checkout -b regular-pr
git add .

Pour des raisons de démonstration, nous allons maintenant ajouter une classe dans le fichier App.css.

.Regular-change-class {
    background-color: white;
}

Après cela, nous ferions un commit et poussons nos modifications sur GitHub. 

git commit -m 'regular CSS change'
git push --set-upstream origin regular-pr

Ensuite, nous ouvrirons une Pull Request sans aucun tag.

Ouverture du second PR (PR urgent)

Maintenant, nous créerions une nouvelle branche urgent-pr, pour nos modifications.

git checkout main
git branch -b urgent-pr

Tout d’abord, nous ferons un commit, où nous créerons un nouveau composant Urgent.js.

import React from "react";

export default function Urgent() {
  return <div>This is an Urgent Change</div>;
}

Ensuite, nous pousserons cette branche (urgent-pr) vers notre dépôt GitHub.

git add .
git commit -m 'Create a component for Urgent change'
git push --set-upstream origin urgent-pr

Puis, nous allons sur notre dépôt et ouvrir une nouvelle PR à partir de la branche urgent-pr vers la branche main en ajoutant une nouvelle étiquette urgent.

Mergify place automatiquement le second PR dans la file d’attente urgent puis exécute les contrôles de CI et le fusionne avec la branche main.

Ensuite, il fusionne automatiquement le premier PR.

Vous pouvez consulter le dépôt GitHub ici pour référence : github.com/hugoescafit/emergency-pr-demo

Conclusion

C’est tout pour cette fois !

Dans ce tutoriel, nous avons exploré le processus de configuration de deux files d’attente de fusion distinctes, par défaut et urgente, avec l’aide de Mergify et de la mise en place des vérifications de CI avec l’aide de CircleCI. Nous avons également vu comment prioriser les PR d’urgence sur les PR réguliers.

Il existe diverses autres solutions pour la gestion des demandes de tirage d’urgence, telles que la création d’une branche spéciale de correction rapide, la mise en place de réviseurs dédiés et même le dépassement manuel des vérifications. Mais les files d’attente de fusion sont l’une des meilleures stratégies faciles à mettre en œuvre pour gérer ce problème.

Visitez Mergify pour commencer à ajouter des files d’attente de fusion à votre application !