pacchetto e strategie di versione in un ambiente multi repository

13

Siamo un'azienda di piccole dimensioni con più team che gestiscono i propri repository git. Questa è una piattaforma web e gli artefatti di ogni squadra vengono distribuiti alla fine della giornata per i test notturni. Stiamo cercando di formalizzare il processo di versioning e packaging.

Ogni team ha un master branch in cui fanno lo sviluppo giorno per giorno. I membri dell'assicurazione della qualità di ogni team desiderano che i manufatti delle modifiche apportate al loro team vengano distribuiti in un banco di prova in cui tutti i componenti sono combinati dallo chef. Gli artefatti sono tarball ma mi piacerebbe convertirli in RPM in modo che possiamo pensare e ragionare sulle versioni correttamente.

Il processo di rilascio comporta il taglio di un ramo di rilascio dal ramo di sviluppo (master nella maggior parte dei casi) di ciascuno dei repository git. Questo viene poi dato alla garanzia della qualità che esegue test e firma su una serie di risorse.

Ad esempio, questo è un tipico repository git con i relativi rami di rilascio associati:

 0-0-0-0-0-0-0-0-0-0 (master)
   |           |
   0           0
 (rel-1)       |
               0
            (rel-2)

Sono bloccato cercando di capire uno schema per eseguire il controllo delle versioni dei pacchetti provenienti dai rami di sviluppo. Non vogliamo etichettare eccessivamente il ramo principale di ciascun repository e limitare i tag solo per rilasciare le filiali. Ma dovremmo essere in grado di interrogare i pacchetti distribuiti nelle macchine di test usando la semantica yum / rpm standard. Come sarebbero le versioni di sviluppo quando il ramo principale non ha tag? Capisco che git describe possa fornirmi una rappresentazione utile di una versione di build ma che funzioni bene quando vari punti di rilascio sul ramo sono taggati.

EDIT1: in risposta alla risposta di @ Urban48

Ho pensato che dovrei spiegare un po 'di più il nostro processo di rilascio. Per gli scopi di questa discussione, supponiamo di avere un ramo master in tutti i repository. Il ramo master è considerato il ramo di sviluppo ed è distribuito in un ambiente QA automatizzato abilitato per l'IC-CD. È qui che viene eseguito un sottoinsieme di test notturni per garantire la stabilità del master. Guardiamo questa pipeline di posti di lavoro prima di tagliare un ramo di rilascio. Le nostre filiali di rilascio sono di breve durata. Dite, dopo aver tagliato un ramo di rilascio (da un master stabile), viene eseguita una regressione completa, le correzioni vengono apportate e distribuite alla produzione. Questo richiede circa una settimana. Rilasciamo quasi ogni due settimane per la produzione.

I nostri rami di funzionalità sono sempre tagliati dal master e sottoposti a una certa quantità di test dello sviluppatore prima di fondersi con il master su cui sono sottoposti ai controlli di stabilità di CI-CD.

Le correzioni rapide vengono eseguite sui rami degli hotfix (tagliati dai rami di rilascio) e implementate con il test dell'impatto minimo in produzione.

La nostra strategia di versioning per i rami release e hotfix segue Semver. Rilasciare i rami durante il ciclo di QA passa attraverso versioni come v2.0.0-rc1 , v2.0.0-rc2 e infine dopo che il QA sign-off diventa v2.0.0 .

A volte facciamo rilasci puntati per piccole funzionalità che vengono unite per rilasciare i rami (e poi per diventare master) dove le versioni diventano v2.1.0 . E gli hotfix assumono il modello v2.1.1 .

La domanda tuttavia non riguarda la versione di questi rami. Preferirei non modificare completamente questo schema di controllo delle versioni. L'unico cambiamento riguarda il ramo di sviluppo, ad es. maestro. Come posso indicare in modo affidabile nell'ambiente CI-CD la versione esistente della versione precedente in produzione. Questo sarebbe idealmente fatto tramite smart git tagging ma è preferibile qualcosa che non tagga eccessivamente il master branch.

    
posta tsps 18.11.2016 - 04:49
fonte

3 risposte

3

Hmm, beh, ho un esempio .net che potrebbe essere indipendente dalla tecnologia.

Farò solo un breve riepilogo.

  • git repo per componente con la strategia di ramificazione di gitflow

  • tutto si impegna a sviluppare l'attivazione di una build di città del team

  • build di teamcity modifica la versione con minore manuale più importante + il numero di build in AssemblyInfo.cs ovvero 1.1.hotfix.build

  • teamcity attiva la confezione di nuget utilizzando lo stesso numero di versione per le librerie pubblicate su nuget

  • octopus distribuisce la compilazione finita in qa per il test manuale (supponendo che tutti i test superino)

  • se tutto è in ordine, distribuisci manualmente la versione in produzione tramite octopus.

Questo vuol dire che ottieni un sacco di pacchetti versionati che galleggiano. Abbiamo fatto esperimenti con l'uso del flag -prerelease, ma questo richiedeva un ulteriore pacchetto di spostamento manuale dalla fase preliminare alla fase "normale" e un requisito per ricostruire i componenti che dipendevano da loro.

La cosa fondamentale è eseguire ogni versione in modo univoco tramite un processo centrale.

Allora ti trovi nella situazione di "hmm quali versioni voglio" piuttosto che "omg, che versione ho?"

Modifica: re commenti.

Solo per sottolineare questa cosa fondamentale. Decidi quale ramo costituisce il software completato e la versione ALL ti impegna. solo distribuire il software con versione da questo ramo.

La mia opinione è che devi affrontare la tua strategia di ramificazione.

  • non eseguire la versione (o eventuali dev) rami
  • fai versione master
  • usa solo pacchetti dal master
risposta data 22.11.2016 - 17:58
fonte
1

Consentitemi di offrire un flusso di lavoro alternativo, che potrebbe risolvere il vostro problema di versione o semplicemente aiutarvi a pensare a un maggior numero di soluzioni per la soluzione.

Un po 'di filosofia prima ..
(Sto facendo alcune supposizioni sul tuo flusso di lavoro, per favore correggimi se sbaglio)

  1. I test vengono eseguiti retroattivamente :

    Filiale di maser per caratterizzare ramo, poi trasformarlo in un artefatto per il test da QA
    il problema è :. E se i test falliscono, allora master può essere rotto!

    effetti collaterali:

    • Rende gli sviluppatori non fidati di master

    • Da quando ti allontani dal master per rilasciare i rami, cosa succede se la versione precedente è stata interrotta? blocca la tua nuova integrazione di funzionalità fino a quando il master non viene riparato.

    • quando un bug viene corretto nel ramo di rilascio, l'unione in master può creare conflitti di unione. (e non ci piacciono i conflitti)

  2. un piccolo codice si fonde e risolve :

    È difficile tenere traccia di tutto il codice che viene unito a master , come piccole correzioni o modifiche che non fanno parte di una determinata funzione.

    effetti collaterali:

      Lo sviluppatore
    • non è sicuro di dover eseguire questa piccola correzione ora o più tardi.

    • dovrei pubblicare anche questa nuova piccola correzione?

    • In qualsiasi momento non è chiaro quale sia lo stato del ramo master e quale codice fluttua lì

    • qualcosa ha rotto la build, che non fa parte della nuova funzionalità. ed è davvero difficile da tracciare da dove proviene

La mia idea per il flusso di lavoro git è la seguente:

ritorna fuori da master per lo sviluppo di nuove funzionalità come fai già. ma ora invece di rilasciare da questo ramo appena creato, avere questa caratteristica selezionata e unita al ramo release .

Ora hai un controllo migliore su ciò che sta accadendo in una certa versione.
Ora è davvero facile isolare le versioni di sviluppo e le versioni stabili.

Puoi continuare a creare artefatti da questi rami di funzionalità per il controllo qualità.
Se tutto è a posto, unisci quella funzione a master e seleziona questa funzionalità / bug-fix / hot-fix nel ramo di rilascio.

delle versioni
La versione di feature branch può utilizzare alcune convenzioni di nomi come 1.2.3-rc.12345

le versioni nel ramo release utilizzeranno solo 1.2.3 ( 1.2.3 > 1.2.3-rc.12345 anche una cosa in meno di cui preoccuparsi)

Questo flusso di lavoro risolve i problemi sopra menzionati, e altro ancora.
Propone anche una strategia di versionamento sensata e la maggior parte di questo ciclo di rilascio può essere automatizzata.

Spero che ti possa aiutare in qualche modo, parlerò volentieri di eventuali casi limite con cui potresti venire a capo.

P.S:
Mi scuso per il mio inglese, non è la mia lingua principale.

    
risposta data 23.11.2016 - 11:09
fonte
0

Il tuo processo sembra molto complicato e ottenere un numero limitato di tag sembra inevitabile.

Mi vengono in mente due idee:

  1. Trattate il ramo "master" come quello che normalmente abbiamo nel ramo "sviluppo". Questo inquina molto il ramo del messaggio.

  2. Quando il QA termina con il proprio lavoro, è possibile avere il server build / CI per creare un report (ad esempio un file di testo) con i tag di tutti i repository in uso. Ora avrai un file con le versioni che possono essere postate sul repository. Quindi tagga il ramo solo con la versione di rilascio e se vuoi controllare le versioni dei singoli componenti puoi controllare il rapporto.

risposta data 29.11.2016 - 03:21
fonte