web-dev-qa-db-fra.com

Comment pouvons-nous garder une trace de quelle version de notre code est dans chaque environnement?

Mon équipe utilise actuellement un processus de ramification/de déploiement assez simple qui ressemble à ceci:

                ┌────────┐ ┌────┐ ┌──────┐
 Environments:  │  DEV   │ │ QA │ │ PROD │
                └────────┘ └────┘ └──────┘

                     ▲       ▲       ▲
                     │       │       │

                ┌────────┐ ┌────┐ ┌──────┐
 Builds:        │  DEV   │ │ QA │ │ PROD │
                └────────┘ └────┘ └──────┘

                     ▲       ▲       ▲
                     │       │       │

                ┌────────┐ ┌────┐ ┌──────┐
 Branches:      │ master │ │ qa │ │ prod │
                └────────┘ └────┘ └──────┘

Chaque environnement a sa propre branche (nous utilisons GIT ) et sa propre construction qui utilise cette branche. Lorsque nous voulons promouvoir d'un environnement à un autre, par exemple, de Dev à QA, nous fusionnons la succursale master dans qa et lancez une nouvelle version QA (qui est ensuite automatiquement déployée sur l'environnement QA).

Nous envisageons de passer à un nouveau processus qui supprimerait une succursale dédiée et une construction pour chaque environnement. Au lieu de cela, une version de version unique créerait un "package de déploiement" qui pourrait ensuite être déployé dans n'importe quel environnement. Nous imaginons qu'un flux de travail typique ressemblerait à ceci comme suit:

                ┌────────┐     ┌────┐     ┌──────┐
 Environments:  │  DEV   │ ──► │ QA │ ──► │ PROD │
                └────────┘     └────┘     └──────┘

                      ▲ 
                       \ 

                        ┌───────────────┐
 Builds:                │ release build │
                        └───────────────┘

                                ▲
                                │

                ┌────────┐ ┌─────────┐
 Branches:      │ master │ │ release │
                └────────┘ └─────────┘

La promotion d'un environnement à un autre ne serait plus traitée dans le contrôle de la source; Nous allions plutôt prendre les fichiers binaires déjà construits (le "package de déploiement") et laisser tomber cela sur le nouvel environnement.

Ce nouveau système nous permettrait de déployer n'importe quelle construction à n'importe quel environnement, qui présente plusieurs avantages. Par exemple, il est trivial de tester des corrections de bugs Prod dans Dev et Qa. Notre système actuel ne fournit pas un moyen simple de le faire sans rouler une branche, que nous aimerions évidemment éviter.

Le plus gros inconvénient avec ce nouveau système est que nous n'avons plus de moyen automatique de suivre quel code est dans lequel l'environnement. Si nous devons faire une solution dans Prod, nous n'avons plus de succursale dédiée en synchronisation avec le code de production actuel. Il en va de même pour QA - si nous voulons appuyer sur un changement rapide en AQ sans draguer des travaux en cours de master, nous n'avons plus de branche qui reflète l'état actuel de l'environnement QA.

Comment pouvons-nous garder une trace de quel code est dans chaque environnement?

Quelques options que nous envisageons:

  • utilisation Tags Git pour suivre la trace de laquelle commit est dans quel environnement
  • incorporer le titre de GIT utilisé par la construction dans chaque package de déploiement
version-controlgitdevelopment-processdeploymentdevelopment-environment
14
Nathan Friend

Les étiquettes GIT sont ce que vous voulez vraiment utiliser pour désigner des versions. La raison en est qu'ils ont un sens pour vous et peuvent être utilisés pour reconnaître rapidement le lien entre le code déployé par l'Etat et toute information que le serveur de construction peut avoir (tel que le numéro de construction).

Bien que c'est la réponse que vous recherchez, cela ne résout que la moitié du problème. L'autre est "hé, voici le déployé .[wje]ar Sur le serveur, quelle version vient-elle? "Nous savons que vous n'aurez jamais différentes versions de l'application déployées sur Dev et QA ou Prod. Droite?

La solution à cette partie de la question est de faire valoir le serveur de construction dans le manifeste. Venir d'un exemple maven et Svn que j'ai devant moi:

<manifestEntries>
    <Specification-Title>${project.name}</Specification-Title>
    <Specification-Version>${project.version}</Specification-Version>
    <Build-Number>${build.number}</Build-Number>
    <Build-Id>${build.id}</Build-Id>
    <Svn-Revison>${svn.revision}</Svn-Revison>
</manifestEntries>

C'est dans la configuration des archives du plug-in Maven-War-War. Mais vous pouvez aussi le trouver dans d'autres plugins. Ensuite, à Hudson, une partie de l'invocation Maven Build est:

-Dbuild.number=${BUILD_NUMBER}
-Dsvn.revision=${SVN_REVISION}
-Dbuild.id=${BUILD_ID}

qui définit ceux qui définissent que puis maven ramasse. Et puis c'est juste une question de recherche dans le fichier manifeste.mf déployé sur le serveur pour voir quelle version elle est.

Il y a un plugin git , qui offre un ensemble similaire de variables d'environnement, notamment:

  • GIT_COMMIT - SHA du courant
  • GIT_BRANCH - Nom du référentiel à distance (par défaut à l'origine), suivi du nom de la succursale actuellement utilisée, par exemple. "Origine/maître" ou "origine/foo"

La combinaison de ces deux pratiques vous permet d'identifier facilement la construction (car les numéros de construction avancent et ont un sens, contrairement aux checksums SHA) et à la validation de GIT spécifique qu'elle est construite.

14
user40980

Une approche complètement différente serait de rejeter l'idée de versions complètement. Vous n'avez que "une version" qui a un comportement configurable différent. La seule différence serait que vous avez une base de code commun - même dans la production que vous voudriez déployer travail en cours: mais non activé.

La différence se résume que dans différents ensembles de fonctionnalités activées dans votre produit.

L'activation/activation est effectuée via Toggles de fonctionnalités .

Upside: Tout le processus de version est simplifié: vous fournissez toujours une version intégrée de votre logiciel. Chaque fonctionnalité est toujours disponible en master. Aucune branche supplémentaire n'est nécessaire.

Il n'y a pas de douleur avec des caractéristiques de fusion, car: aucune branche n'a pas besoin de fusionner. Il n'y a pas de confusion quelle caractéristique est sur quelle branche et peut-être dépendre ou des affrontements avec des caractéristiques d'autres branches. Chaque partie pourrait être activée à volonté. Même A Rollback n'est plus nécessaire: ce n'est qu'un Flip d'un commutateur.

Je ne sais pas, si cela fonctionne pour votre codeBase: Les prérequis en termes de qualité de code et de discipline de développeur sont assez élevés - vous devez faire face à "nettoyage" après A fonctionnalité devient A MORE FONCTIONNALITÉ et vous devez gérer Un tas de TOGGLES Empêcher un fichier plus grand mess.

Peut-être cela fonctionne-t-il pour vous.

3
Thomas Junk