Que pouvez-vous faire pour diminuer le nombre de bogues de déploiement d'un site Web en direct?

Je suis sûr que beaucoup d'entre vous ont rencontré ce problème. Un site Web ou une application Web est en cours d'exécution et est en ligne. Vous voulez télécharger la prochaine version, mais vous n'avez pas tout compris, comme définir une valeur sur false dans le fichier de configuration, insérer un autre enregistrement dans la base de données et faire beaucoup de choses mineures qui peuvent parfois compter jusqu'à 20 paramètres ou plus.

Dès que vous téléchargez la nouvelle version, tout se casse. Maintenant, la résolution du problème peut ne prendre que 20 minutes, mais le stress global que vous tolérez et les dommages financiers et de bonne volonté de l'entreprise ne sont parfois pas oubliables.

Quels sont les moyens de réduire ces types de bogues résultant de la configuration initiale du déploiement de la nouvelle version?

PS: Veuillez ne pas mentionner les listes de contrôle, car nous les avons déjà. Le problème avec les listes de contrôle est qu'elles devraient toujours être mises à jour, mais ce n'est pas le cas.

Deux choses:

• Environnement de transfert, similaire à l'environnement en direct dans lequel vous testez les déploiements.
• De nombreux tests de cet environnement après le déploiement. Automatisé et non automatisé.

Il y a d'autres choses qui peuvent être faites.

Je suggère de lire la série de blogs en 5 parties sur le déploiement automatisé par Troy Hunt. L'outillage qu'il utilise est spécifique à la pile MS, mais les concepts sont universels.

Je me demande pourquoi personne n'a mentionné le contrôle de version - qui est l'un des moyens les plus importants de vous éviter des problèmes lors de la mise à jour / mise à niveau.

Tout d'abord, votre déploiement ne doit être qu'un clone de la branche stable de votre référentiel. Tout, y compris les fichiers de configuration, les fichiers SQL, les scripts d'installation / mise à jour DOIT être contrôlé par la version.

Deuxièmement, vous devez avoir "une sorte de" zone de transit - cela peut être n'importe quoi - un serveur local, un serveur cloud virtuel temporaire que vous venez d'apparaître, une configuration d'hôte virtuel très simple ou une application personnalisée à part entière qui vous maintenez avec l'application principale. La différence entre cette «zone de transit» et votre «zone de développement» est que la première modélise (ou simule) plus étroitement votre environnement de déploiement réel. Par exemple, vous pouvez développer sur PHP 5.3.x avec le module Apache, mais comme votre hôte est PHP 5.2.x avec FCGI, votre zone de transit doit être la même.

Ensuite, vous écrivez et testez d'abord vos mises à jour sur votre environnement de développement. Fusionnez ces modifications dans le référentiel de la zone de transit, puis testez à nouveau. À ce stade, vous pouvez apporter des modifications à votre configuration en fonction de votre déploiement - étant donné que sa version est contrôlée, rien ne sera perdu et vous pouvez toujours revenir en arrière en cas de problème.

Enfin, fusionnez les modifications de la zone de transit sur votre copie de déploiement en direct.

La complexité de votre zone de transfert doit refléter la complexité et la portée de votre application. Mais dans tous les cas, le contrôle de version est indispensable.

Bien sûr, si vous n'utilisez pas le contrôle de version - rien de tout cela ne s'applique - mais c'est aussi naïf que d'écrire une base de données dans Logo.

Comme suggéré, utilisez un système de mise en scène . Cela vous donne la possibilité de tester vos modifications dans un environnement réel.

Cela soulève un autre point: avoir des testeurs . Tester les choses que j'ai écrites moi-même ne trouve pas autant de bugs que quand quelqu'un d'autre teste mon application.

Autre chose: automatisez votre processus de déploiement . Faites des migrations db avec ant migrate, déployez automatiquement la dernière version depuis svn via capistrano etc. Lorsque vous déployez quelque chose, vous ne devriez pas avoir à faire plus qu'un simple clic et tout est automatique. Surtout pour les sites Web qui nécessitent une configuration, les étapes manuelles requises pour le déploiement sont un cauchemar et la possibilité que quelque chose tourne mal est énorme.

Pour quelque chose qui ne doit absolument pas casser, pensez à avoir un système A et B et utilisez un équilibreur de charge pour acheminer toutes les demandes vers A pendant que vous mettez à niveau et testez B, puis acheminez tout vers B pendant que vous mettez à jour A.

Pour les points bonus, ajoutez C et assurez-vous que vos systèmes sont géographiquement séparés afin qu'un tremblement de terre n'en supprime pas 2 simultanément.

Pour de nombreuses applications, j'avoue que c'est exagéré.

Cela complique également la gestion des transactions que vous devez faire, mais les problèmes ne sont pas insurmontables.

Oui, vous avez besoin d'un environnement de test ou de transfert dans lequel vous passez par toutes les étapes, mais la conservation de fichiers de configuration séparés pour des environnements distincts est un must.

Environments
|_property_files
    |_ dev
        |_ com.bla.util
        |    |_ example.properties
        |_ com.bla.beans
        |    |_ someconfig.xml
    |_ test
        ....
    |_ production
        ....
|_database_updates
    |_ dev
        |_ insert_new_static_data.sql
        |_ ...

...

Fondamentalement, dans mes scripts de génération et de déploiement, je prends une propriété d'environnement qui récupérera les fichiers de métadonnées spécifiques à l'environnement comme les fichiers XML et les remplacera dans mon emplacement de génération avant l'empaquetage. Plus loin dans mes scripts de déploiement, je rechercherai tous les fichiers SQL dans les mises à jour de base de données et les exécuterai également sur la base de données configurée pour cet environnement.

Je pourrais le faire avec une tâche de construction personnalisée, mais j'utilise en fait juste quelques tests JUnit pour le faire pour moi. Si des exceptions SQL se produisent, le test échoue et le déploiement échoue. De manière générale, les scripts SQL ont également une intelligence, si les données nécessaires existent déjà dans l'environnement, ils sautent l'insertion ou la mise à jour.

J'ai également un répertoire similaire pour les scripts batch ou shell que je dois exécuter pour un environnement spécifique.

Le tout dans votre question est le suivant: ils devraient toujours être mis à jour, mais ils ne le feront pas.

Ces configurations pilotent vos builds et déploiements automatisés, donc si vous ne les mettez pas à jour, vos builds échouent et votre responsable reçoit un e-mail à ce sujet. Il est donc tout aussi important pour l'équipe de maintenir les configurations de construction et de déploiement pour une version spécifique que pour elle de vérifier le code qui compile. L'une ou l'autre infraction rompt la construction.

En bref, une plus grande adoption des principes d' intégration continue (CI) aidera à éliminer la douleur des versions de production.

1) Déployez d'abord sur le site de test et testez vos modifications

2) Avoir toute la configuration dans un fichier de configuration (web config ou similaire). Cette configuration doit alors être spécifique à l'application et jamais écrasée. Tout changement est ensuite délibéré plutôt que d'oublier de changer quelque chose qui devrait être différent du test.

En plus des excellentes suggestions ci-dessus pour avoir un environnement de pré-production et utiliser des tests automatisés:

Réduisez la complexité de la base de code. Moins de code, généralement, signifie moins de bogues et plus de facilité à les trouver. Telle est la philosophie derrière la refactorisation, la séparation des préoccupations, etc.

Segmentez la base de code . Une approche courante consiste à le séparer en:

• quelques parties centrales qui changent lentement et sont partagées sur le site
• de nombreuses parties des feuilles qui peuvent changer plus rapidement, mais chacune n'a d'impact que sur une plus petite partie du site

Cette compréhension de votre base de code vous permet de concentrer votre développement et vos tests sur les parties principales, car les bogues auront l'effet le plus drastique.

Une version bien exécutée est une question de planification et de communication. Donc, avant de procéder à une version, considérez ces questions:

1. Combien de temps la version est-elle susceptible de prendre, et y a-t-il des risques à laisser les gens continuer à interagir avec mon produit pendant que la version est en cours? S'il existe un risque pour le système, envisagez de le mettre hors ligne et de mettre en place un message "Système en cours de maintenance" à sa place.

2. Y a-t-il des clients dont vous pourriez avoir besoin de notifier la version à l'avance? Dois-je leur signaler une éventuelle interruption de service ou une dégradation des performances pendant la publication? Personnellement, je préfère toujours trop communiquer et informer tous les clients d'une prochaine version ou fenêtre de maintenance sur un blog public ou un lieu similaire.

3. Quels sont mes plans d'urgence si la libération devait mal tourner? Par exemple, si la version se passe mal, devrions-nous revenir en arrière et restaurer le système tel qu'il était pour minimiser le temps que nous sommes hors ligne? Et si oui, les étapes de restauration d'une version sont-elles bien documentées? Ou devrais-je avoir les bonnes personnes sur appel ou à portée de main afin d'aider à résoudre les problèmes s'ils se produisent. Personnellement, je pense que la meilleure façon d'aborder la planification d'une version est de supposer que quelque chose ne va pas avec la version. De cette façon, je me suis forcé à réfléchir à l'avance à certaines de ces questions.

Ensuite, en ce qui concerne l'exécution d'une version, l'un des meilleurs moyens de garantir son bon fonctionnement est de s'exercer, de s'exercer, de s'exercer et de documenter tout ce que vous rencontrez en cours de route.. Donc, bien avant de déployer le nouveau code en production, entraînez-vous d'abord à déployer le code dans un environnement de transfert sécurisé et correctement mis en bac à sable. Demandez à la personne qui sera responsable du déploiement en production d'exécuter le déploiement de test en amont. Considérez ceci comme votre répétition générale et conduisez-vous comme vous le feriez si c'est la vraie chose. Documentez tout ce que vous faites à chaque étape du processus; documenter chaque commande que vous exécutez, tout code SQL que vous exécutez, tous les fichiers que vous modifiez et la façon dont vous les avez modifiés et pour chaque étape du processus, documentez ce que vous attendez de voir si la procédure est exécutée correctement. Si et quand vous rencontrez un problème quelconque, documentez ce que vous avez fait pour le résoudre.

Ensuite, le déploiement de la pratique est terminé, examinez vos notes et voyez si vous pouvez affiner le processus pour éliminer les erreurs. Puis recommencez . Continuez à pratiquer jusqu'à ce que l'exécution d'une version devienne aussi routinière que de suivre une simple feuille d'instructions, comme "se connecter à cette machine, exécuter cette commande; puis se connecter à la base de données et exécuter cette commande SQL; puis ..."

La liste ci-dessus répertorie les actions qu'une équipe de gestion des opérations ou des versions peut effectuer pour assurer le bon déroulement d'une version. Mais que peut faire l'ingénierie pour minimiser les risques dans une version?

1. Gardez les versions petites. Autrement dit, plus l'ensemble des modifications de code contenues dans une version est complexe, plus la version sera risquée. Faites plaisir à votre équipe d'exploitation en prévoyant d'avoir un plus grand nombre de petites versions, plutôt qu'un plus petit nombre de grandes versions sur la même période.

2. Test, test, test. Ne vous contentez pas de tester votre code dans votre environnement QA, utilisez également l'environnement de test pour tester votre logiciel. Il y a souvent des bogues qui ont peu ou rien à voir avec le code lui-même, mais qui ont plutôt une cause profonde qui réside dans la configuration de l'environnement lui-même (ou un mélange des deux). Pour trouver ces problèmes, vous devez tester votre code dans un environnement qui reflète étroitement la production, autrement dit la mise en scène.

En dernier mot, parfois ce qui est le plus important n'est pas ce que nous faisons pour empêcher que les choses tournent mal, mais c'est la façon dont nous nous comportons quand elles tournent mal. Par conséquent, je pense qu'il est important de construire une culture dans votre entreprise autour de la transparence opérationnelle. N'essayez pas de cacher les problèmes des clients, soyez à venir. Utilisez Twitter activement pour informer les clients s'il y a des problèmes que votre équipe opérationnelle est actuellement au courant et s'efforce de résoudre ( Lighthouse est génial à cela!). Pensez à publier une page "état" pour votre service que les clients peuvent consulter pour voir si quelque chose ne va pas ( TypePad en offre un excellent exemple). En bout de ligne, toujours pécher par excès de communication. Vos clients vous en remercieront.

De nombreuses réponses ici vous indiquent déjà comment implémenter votre solution spécifique au problème, mais, pour autant que je sache, le vrai problème n'est pas celui de la migration / mise à jour correcte d'un site Web. Il se peut que la conception / architecture derrière elle soit fragile.

Si cela est vrai, vous devrez ajuster l'architecture de votre système de sorte qu'elle soit suffisamment robuste pour continuer à fonctionner correctement même si les paramètres de configuration changent ou ne sont pas correctement définis, et qu'elle se dégrade gracieusement si elles se produisent. Idéalement, si vous avez ajouté de nouvelles fonctionnalités ou changé d'anciennes fonctionnalités d'une manière qui nécessite une nouvelle colonne de base de données, votre site fonctionnera même si la colonne est manquante (peut-être sans la nouvelle fonctionnalité, ou avec une forme dégradée de l'ancienne fonctionnalité) . Votre client ne devrait pas perdre d'argent - au pire, il pourrait ne pas obtenir de nouveaux fonds grâce aux améliorations que vous avez apportées.

Si votre système est suffisamment fragile pour que les paramètres de configuration puissent causer des problèmes aussi graves, les mises à jour du programme ne seront pas les seules sources de problèmes - et découvrir comment effectuer les mises à jour en toute sécurité ne fera qu'augmenter les dommages que vous rencontrerez en cas d'échec. une source différente.