Gestione delle Richieste di Pull di Emergenza Utilizzando Code Queue

Gestire le richieste di pull d’emergenza è stato oggetto di dibattito nella comunità dei developer sin dall’avvento delle pratiche Agile e DevOps.

In tali scenari, abbiamo bisogno di un sistema in grado di dare la priorità a queste ‘richieste urgenti’ rispetto alle PR regolari e che ci consenta di posticipare alcuni controlli di CI se necessario.

Una buona strategia potrebbe essere quella di implementare un coda di merge separata, che ci permetta di anticipare la coda predefinita anche prima che i test di CI siano passati e accelerare le nostre correzioni urgenti verso la produzione.

In questo articolo, creeremo due code di merge con Mergify attivate da etichette di PR. Configureremo una per le PR regolari e l’altra per gestire le PR d’emergenza.

Quindi, arrotoliamo le maniche e iniziamo! 

Per questa dimostrazione, stiamo per avviare una semplice applicazione React. E per il CI, utilizzeremo CircleCI.

Creeremo due code di merge:

• default: Tutte le PR passeranno attraverso di essa regolarmente. Richiede controlli CircleCI prima di procedere.
• urgent: Questa coda è solo per le PR che hanno l’etichetta urgente nella PR. Questo consente alle PR di saltare in testa alle PR nella coda predefinita senza eseguire controlli CircleCI.

Con una tale configurazione, una pull request con l’etichetta urgente entrerà nella coda prima che il CI sia stato eseguito su di essa.

Sarà davanti alla coda predefinita. Mergify aggiornerà la pull request con la sua branch base se necessario, aspetterà che il CI passi, e poi unirà la pull request.

Anche dal punto di vista del team di sviluppo, questo è un processo piuttosto semplice. Il developer deve solo aggiungere un’etichetta urgente durante la creazione della PR per accelerare il processo.

Configurazione del Nostro Progetto

Iniziamo configurando il nostro progetto. Creeremo una nuova applicazione React utilizzando create-react-app.

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

Per riferimento, questa sarà la struttura finale del nostro progetto dopo aver aggiunto la configurazione CI e 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

Creazione Configurazione CI

Per eseguire i nostri test, utilizzeremo CircleCI. È facile da configurare e iniziare.

Qui, creeremo un file config.yml in una nuova directory .circleci nella radice del nostro progetto.

Creeremo un semplice job build_and_test che ci aiuterà prima a verificare se il nostro progetto viene costruito come previsto e poi eseguirà i test unitari con il comando 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

Creazione Configurazione Mergify

Ora è il momento di creare il nostro file di configurazione Mergify.

Mergify è uno strumento che automatizza il processo di fusione delle pull request nei repository di codice in base a regole e condizioni predefinite.

Abbiamo bisogno di definire due code nel nostro file di configurazione come pianificato: urgente e default.

Entrambi hanno gli stessi merge_conditions, check-success=ci/circleci: build_and_test, il che significa che il codice deve superare con successo il controllo build_and_test in CircleCI prima che possa essere fuso.

La sezione pull_request_rules illustra come gestire le richieste di pull. Metteremo il nostro PR nella coda urgent se ha l’etichetta urgente. In caso contrario, entrerà nella coda predefinita.

.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

Configurazione del Repository

No, procederemo creando un nuovo repository su GitHub. 

Dopo questo, dovremo effettuare un commit iniziale e spingere il nostro codice utilizzando i seguenti comandi:

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

Successivamente, dovremo configurare CircleCI. Per fare ciò, visiteremo il Dashboard CircleCI, quindi andremo alla sezione dei progetti e configureremo il nostro progetto.

Dovremo anche specificare la nostra main branch. CircleCI rileverà automaticamente il nostro file config in questo caso.

Possiamo installare Mergify nel nostro account GitHub visitando dashboard.mergify.com o github.com/apps/mergify/installations/new e accedendo con il nostro account GitHub.

Quindi, potremmo selezionare i repository a cui vogliamo concedere l’accesso a Mergify.

Una volta configurato, saremmo in grado di vedere entrambe le nostre code nel Dashboard di Mergify. 

Sollevamento del Primo PR (PR Regolare)

Ora iniziamo creando il nostro primo PR. Prima creeremo un nuovo ramo regular-pr

git checkout -b regular-pr
git add .

Solo per scopi dimostrativi, ora aggiungeremo una classe nel file App.css.

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

Successivamente, faremo un commit e pubblicheremo le nostre modifiche su GitHub. 

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

Quindi, solleveremo una Pull Request senza etichette.

Sollevamento del Secondo PR (PR Urgente)

Ora creeremo un nuovo ramo urgent-pr, per le nostre modifiche.

git checkout main
git branch -b urgent-pr

In primo luogo, faremo un commit, dove creeremo un nuovo componente Urgent.js.

import React from "react";

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

Ora, pubblicheremo questo (urgent-pr) ramo nel nostro repo GitHub.

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

Quindi, andremo al nostro repo e solleveremo una nuova PR dal ramo urgent-pr al ramo main e aggiungeremo una nuova etichetta urgent.

Mergify mette automaticamente il secondo PR nella coda urgent poi esegue i controlli di CI e lo unisce al ramo main.

Quindi, unisce automaticamente il primo PR.

Puoi consultare il repository GitHub qui per riferimento: github.com/hugoescafit/emergency-pr-demo

Conclusione

Questo è tutto per questa volta!

In questo tutorial, abbiamo esplorato il processo di configurazione di due code di merge distinte, predefinita e urgente, con l’aiuto di Mergify e di impostare i controlli di integrazione continua con l’aiuto di CircleCI. Abbiamo anche visto come dare la priorità ai PR di emergenza rispetto a quelli regolari.

Esistono varie altre soluzioni per la gestione delle richieste pull di emergenza, come la creazione di un ramo speciale per hotfix, avere revisori dedicati e persino l’override manuale dei controlli. Ma le code di merge sono una delle migliori e più semplici strategie da implementare per gestire questo problema.

Visita Mergify per iniziare ad aggiungere code di merge al tuo applicativo!