Strategia di branching Git per un team appena magro

Question

Abbiamo un'app Web per la quale abbiamo un paio di clienti aziendali. Recentemente abbiamo deciso di offrirlo come app SaaS e di seguire l'approccio lean (in parallelo con la nostra offerta aziendale). Il che significa che abbiamo degli esperimenti in movimento che potrebbero non essere in produzione.

Prima siamo andati magra siamo stati felici con la seguente strategia ramificazione (credo che sia abbastanza standard):

• maestro - sempre stabile
• dev - spesso instabili (funzione rami tagliati di dev per le nuove funzionalità a passare alla prossima versione principale)
• major_release_x - live (interruzione del master dopo dev è stato unito in maestro, questo è dove correzioni di bug si svolgono e fuse indietro nel master e dev)

Ora abbiamo i seguenti in aggiunta a quanto sopra e non funziona tanto bene:

• lean_release_branch - vivere (tagliare la major_release_x e contiene esperimenti)
• experiment_x - tagliare major_release_x (è qui che hackerare il caratteristica insieme e poi m si erge in lean_release_branch)

Il nostro scenario ora è che abbiamo bisogno di sgancio rapido e spesso come l'approccio lean impone, e quando si ottiene un feedback solida su qualcosa di arbitrario, quindi abbiamo bisogno di productionize e rilasciarlo non appena possibile (fuori dal lean_release_branch).

Il problema è che non possiamo creare un ramo di caratteristica fuori del dev (come è più probabile instabile) e non siamo in grado di creare un ramo di caratteristica fuori del lean_release_branch per due motivi:

1. è stato contaminato da codice esperimento in modo tale variazione/funzione non sarà in grado di fare il suo ritorno a maestro
2. il lean_release_branch sempre bisogno di essere pronto a rilasciare, in modo da non possiamo essere occupati fare test e correzioni su di esso (dopo aver unito la modifica/funzione in esso) se c'è un problema critico che deve essere risolto e rilasciato

Qualcuno sa di una strategia migliore per il nostro setup?

Answer 1

Ho appena cambiato da TFS a GIT e il modello che seguo si basa su questo post.

Per quanto riguarda gli esperimenti, si tratta di "rami in primo piano" che non torneranno a sviluppare (uniti nello sviluppo).

Answer 2

Perché tutto in major_release_x è già in dev (dal dev è stata fusa in maestro prima dell'ultima major release) una caratteristica productionised (a seguito di un esperimento riuscito) può essere fatto su un ramo di caratteristica off major_release_x, lo chiamano production_feature_y, e poi uniti in entrambi dev, di essere nella prossima major release, e lean_release_branch.

In questo modo le nuove funzionalità di produzione sono disponibili nella versione snella e saranno disponibili nella prossima versione principale e il ramo snello non deve mai essere nuovamente unito.

ulteriori feedback sulla funzione può essere implementata su production_feature_y e fuse in dev e lean_release_branch di nuovo.

Correzioni possono essere gestiti nello stesso modo, fatto su un ramo major_release_x e fusi in entrambi major_release_x e lean_release_branch.

Answer 3

Oltre a menzionare GitFlow nozari, c'è anche GitHub Flow. Il posto in cui lavoro l'ha usato come base (il master è sempre stabile, si sviluppa nei rami delle funzionalità, richiama la richiesta con revisione prima della fusione). Distribuiamo meno spesso di quanto fa GitHub, quindi su master usiamo annotated tags per tenere traccia delle versioni e i tag leggeri puntano a qualsiasi commit sia in fase di staging/produzione. Questo è gestito dalla gemma Rubino capistrano-deploytags.

A meno che non sto leggendo il problema in modo errato, è possibile ottenere lo stesso con questa strategia con meno complessità in tutti quei rami.