Umgang mit Notfall-Pull-Anfragen mithilfe von Merge-Warteschlangen

Die Handhabung von Notfall-Pull-Anfragen ist seit Einführung agiler und DevOps-Praktiken ein Diskussionsthema in der Entwicklercommunity.

In solchen Situationen benötigen wir ein System, das diese „dringenden“ Anfragen gegenüber regulären PRs priorisiert und es uns ermöglicht, einige CI-Prüfungen gegebenenfalls zu verschieben.

Eine gute Strategie könnte sein, eine gesonderte Merge-Warteschlange einzurichten, die es uns erlaubt, vor Abschluss der CI-Tests und der Beschleunigung unserer dringenden Fixes in die Produktion vor dem Standard-Queue zu gelangen.

In diesem Artikel werden wir zwei Merge-Warteschlangen mit Mergify erstellen, die durch PR-Labels ausgelöst werden. Wir werden eine für reguläre PRs und eine andere zur Handhabung von Notfall-PRs konfigurieren.

Also, rollen wir die Ärmel hoch und fangen an!

Für diese Demo werden wir eine einfache React-Anwendung initialisieren. Und für CI werden wir CircleCI verwenden.

Wir werden zwei Merge-Warteschlangen erstellen:

• default: Alle PRs werden regelmäßig darüber laufen. Es erfordert CircleCI-Prüfungen vor der Verarbeitung.
• urgent: Diese Warteschlange ist nur für PRs, die das dringende Label in der PR haben. Dies ermöglicht PRs, vor den PRs in der Standardwarteschlange zu springen, ohne CircleCI-Prüfungen durchlaufen zu müssen.

Mit einer solchen Konfiguration wird eine Pull-Anfrage mit dem Label dringend vor dem CI in die Warteschlange eintreten.

Sie wird vor der Standardwarteschlange stehen. Mergify wird die Pull-Anfrage gegebenenfalls mit ihrer Basis-Branch aktualisieren, auf das Passieren der CI warten und dann die Pull-Anfrage mergen.

Von der Sicht des Entwicklungsteams aus gesehen ist dieser Prozess ebenfalls recht einfach. Der Entwickler muss lediglich beim Erstellen des Pull Requests ein urgent Label hinzufügen, um den Prozess zu beschleunigen.

Einrichten unseres Projekts

Fangen wir mit der Einrichtung unseres Projekts an. Wir würden eine neue React-Anwendung mit create-react-app erstellen.

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

Zur Referenz, dies wird unsere endgültige Projektstruktur sein, nachdem wir unsere CI und Mergify-Konfiguration hinzugefügt haben.

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

Erstellen der CI-Konfiguration

Zum Ausführen unserer Tests werden wir CircleCI verwenden. Es ist einfach einzurichten und zu starten.

Hier werden wir eine config.yml Datei in einem neuen .circleci Verzeichnis im Stammverzeichnis unseres Projekts erstellen.

Wir werden einen einfachen Job build_and_test erstellen, der zunächst dabei hilft, zu überprüfen, ob unser Projekt wie erwartet erstellt wird, und dann die Einheitstests mit dem npm run test Befehl ausführt.

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

Erstellen der Mergify-Konfiguration

Jetzt ist es an der Zeit, unsere Mergify Konfigurationsdatei zu erstellen.

Mergify ist ein Werkzeug, das den Prozess des automatischen Zusammenführens von Pull Requests in Code-Repositories basierend auf vordefinierten Regeln und Bedingungen automatisieren.

Wir müssen in unserer Konfigurationsdatei zwei Warteschlangen wie geplant definieren: urgent und default.

Beide verwenden dieselbe merge_conditions, check-success=ci/circleci: build_and_test, was bedeutet, dass der Code erfolgreich die build_and_test Prüfung in CircleCI bestehen muss, bevor er zusammengeführt werden kann.

Der Abschnitt pull_request_rules legt fest, wie Pull Requests behandelt werden sollen. Wir werden unseren PR in die dringend Warteschlange stellen, wenn er das Etikett dringend hat. Andernfalls gelangt er in die Standardwarteschlange.

.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

Einrichtung des Repository

Nein, wir würden einen neuen Repository auf GitHub erstellen. 

Danach müssen wir einen ersten Commit machen und unser Code mit den folgenden Befehlen pushen:

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

Als nächstes müssen wir CircleCI einrichten. Dafür besuchen wir die CircleCI Dashboard, gehen dann zum Bereich Projekte und richten unser Projekt ein.

Wir müssen auch unsere main Branch angeben. CircleCI erkennt in diesem Fall automatisch unser config Datei.

Wir können Mergify in unserem GitHub-Konto installieren, indem wir die dashboard.mergify.com oder github.com/apps/mergify/installations/new besuchen und uns mit unserem GitHub-Konto anmelden.

Anschließend können wir die Repositorys auswählen, denen wir Mergify Zugriff gewähren möchten.

Sobald eingerichtet, können wir beide Warteschlangen im Mergify-Dashboard sehen.

Erstellen des ersten Pull Requests (Regulärer PR)

Beginnen wir nun mit der Erstellung unseres ersten Pull Requests. Zuerst erstellen wir einen neuen Branch regular-pr

git checkout -b regular-pr
git add .

Nur zu Demonstrationszwecken werden wir nun eine Klasse im App.css-Datei hinzufügen.

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

Danach werden wir einen Commit vornehmen und unsere Änderungen auf GitHub pushen.

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

Als nächstes erstellen wir eine Pull Request ohne Tags.

Erstellen des zweiten Pull Requests (Dringender PR)

Nun erstellen wir einen neuen Branch urgent-pr für unsere Änderungen.

git checkout main
git branch -b urgent-pr

Zuerst werden wir einen Commit vornehmen, bei dem wir eine neue Komponente Urgent.js erstellen.

import React from "react";

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

Jetzt werden wir diesen (urgent-pr) Branch in unserem GitHub-Repo pushen.

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

Dann gehen wir zu unserem Repo und erstellen eine neue PR von urgent-pr Branch zum main Branch und fügen dabei eine neue Beschriftung urgent hinzu.

Mergify legt den zweiten PR automatisch in die urgent-Warteschlange und führt die CI-Prüfungen durch, um ihn dann mit dem main-Branch zu verschmelzen.

Anschließend wird der erste PR automatisch verschmolzen.

Sie können sich das GitHub-Repository hier ansehen für Referenz: github.com/hugoescafit/emergency-pr-demo

Schlussfolgerung

Das war’s für dieses Mal!

In diesem Tutorial haben wir den Prozess untersucht, zwei verschiedene Merge-Warteschlangen, Standard und Dringend, mit Hilfe von Mergify einzurichten, und CI-Überprüfungen mit Hilfe von CircleCI einzurichten. Wir haben auch gesehen, wie dringende PRs gegenüber regulären PRs priorisiert werden können.

Es gibt verschiedene andere Lösungen für die Verwaltung von dringenden Pull-Anforderungen, wie z. B. die Erstellung einer speziellen Hotfix-Branch dafür, die Beaufsichtigung durch spezialisierte Prüfer und sogar das manuelle Überschreiben von Prüfungen. Merge-Warteschlangen sind jedoch eine der besten und einfach umzusetzenden Strategien, um dieses Problem zu bewältigen.

Besuchen Sie Mergify, um Merge-Warteschlangen für Ihre Anwendung hinzuzufügen!