Technologies DevOps : automatisation des déploiements

L'automatisation des déploiements vous permet de déployer votre logiciel dans des environnements de test ou de production en appuyant simplement sur un bouton. L'automatisation est essentielle pour réduire les risques inhérents aux déploiements en production. Il est également essentiel pour vous de pouvoir rapidement obtenir un retour sur la qualité de votre logiciel. Pour cela, vous devez permettre aux équipes de réaliser des tests exhaustifs dès que possible après chaque modification.

Un processus de déploiement automatisé se compose des éléments suivants :

  • Des packages générés dans le cadre du processus d'intégration continue (CI). Ces packages doivent pouvoir être déployés dans tout environnement, y compris en environnement de production.
  • Des scripts permettant de configurer l'environnement, de déployer les packages et d'effectuer un test du déploiement (parfois appelé test de confiance).
  • Des informations de configuration spécifiques à l'environnement.

Nous vous recommandons de stocker les scripts et les informations de configuration dans le contrôle des versions. Votre processus de déploiement doit télécharger les packages à partir d'un dépôt d'artefacts (par exemple, Container Registry, Nexus, Artifactory ou le dépôt intégré de votre outil d'intégration continue).

Les scripts effectuent généralement les tâches suivantes :

  1. Ils préparent l'environnement cible. Ils peuvent par exemple installer et configurer les logiciels nécessaires, ou encore démarrer un hôte virtuel à partir d'une image préparée à l'avance et hébergée auprès d'un fournisseur cloud tel que Google Cloud.
  2. Ils déploient les packages.
  3. Ils effectuent certaines tâches liées au déploiement. Ils peuvent par exemple lancer l'exécution des scripts de migration de base de données.
  4. Ils effectuent toutes les opérations de configuration requises.
  5. Ils effectuent en dernier lieu un test de déploiement afin de garantir que tous les services externes nécessaires sont accessibles et que le système fonctionne.

Comment mettre en œuvre l'automatisation du déploiement

Lorsque vous concevez votre processus de déploiement automatisé, nous vous recommandons de respecter ces bonnes pratiques :

  • Utilisez le même processus de déploiement pour tous les environnements, y compris l'environnement de production. Cette règle permet de vous assurer que le processus de déploiement est testé plusieurs fois avant le déploiement en production.
  • Autorisez toute personne disposant des identifiants nécessaires à déployer n'importe quelle version de l'artefact de façon totalement automatisée dans n'importe quel environnement à la demande. Si vous devez à chaque itération créer un ticket et attendre que quelqu'un prépare l'environnement, cela signifie que votre processus de déploiement n'est pas entièrement automatisé.
  • Utilisez les mêmes packages pour tous les environnements. Cette règle implique que vous devez maintenir les configurations spécifiques aux différents environnements séparées des packages. En suivant cette règle, vous avez la garantie que les packages que vous déployez en production sont les mêmes que ceux que vous avez testés.
  • Faites en sorte qu'il soit possible de recréer l'état de n'importe quel environnement à partir des informations stockées dans le contrôle des versions. Cette règle permet de s'assurer que les déploiements sont reproductibles et que, dans l'éventualité d'un scénario de reprise après sinistre, vous serez en mesure de restaurer l'état de production de manière déterministe.

Idéalement, pour effectuer les déploiements, vous devriez disposer d'un outil permettant de consigner les versions exécutées à l'instant T dans chaque environnement et d'enregistrer les résultats du processus de déploiement à des fins d'audit. De nombreux outils d'intégration continue offrent de telles fonctionnalités.

Problèmes courants liés à l'automatisation du déploiement

Lorsque vous tentez d'automatiser votre processus de déploiement, vous devez faire face aux écueils suivants :

  • Complexité du processus existant
  • Dépendances entre services
  • Composants qui ne sont pas conçus pour l'automatisation
  • Mauvaise collaboration entre les équipes

Complexité

Le premier écueil est lié à la complexité inhérente aux déploiements. Le fait d'automatiser un processus manuel complexe et fragile produit un processus automatisé complexe et fragile. Vous devez en premier lieu repenser votre processus dans l'optique de faciliter les déploiements. Cela signifie que vous devez simplifier autant que possible le script de déploiement et déporter la complexité au niveau du code de l'application et de la plate-forme d'infrastructure. Identifiez les conditions d'échec des déploiements et trouvez comment les contourner en rendant vos services, vos composants, votre plate-forme d'infrastructure et vos outils de surveillance plus intelligents. Les applications cloud natives qui s'exécutent dans un environnement Platform as a Service, tel que App Engine, Cloud Run ou Pivotal Cloud Foundry peuvent généralement être déployées à l'aide d'une seule commande. Aucun script de déploiement n'est nécessaire pour cela : ce type de processus est considéré comme idéal.

Il existe deux propriétés importantes caractérisant un processus de déploiement fiable. Premièrement, les différentes étapes du processus de déploiement doivent dans la mesure du possible être idempotentes. Vous pourrez ainsi les répéter autant de fois que nécessaire en cas de survenue d'un échec. Deuxièmement, elles ne doivent pas être soumises à un quelconque ordre d'exécution. En d'autres termes, les composants et les services ne devraient pas subir de plantages intempestifs si un autre composant ou service attendu est absent. Au lieu de cela, les services devraient continuer à fonctionner en mode dégradé jusqu'à ce que leurs dépendances soient à nouveau disponibles.

Pour les nouveaux produits et services, nous vous recommandons de considérer ces principes comme des exigences système dès le début de la phase de conception. Si vous adaptez l'automatisation à un système existant, il sera certainement nécessaire de travailler à la mise en œuvre de ces caractéristiques ou d'intégrer une solution de télémétrie permettant au processus de déploiement de détecter correctement les états incohérents et les défaillances.

Dépendances

Le deuxième problème tient au fait que de nombreux processus de déploiement, en particulier dans les environnements d'entreprise, nécessitent une orchestration. En d'autres termes, vous devez déployer plusieurs services ensemble dans un ordre particulier, et dans le même temps effectuer d'autres tâches telles que la migration de bases de données, le tout en assurant une synchronisation parfaite. Bien que de nombreux outils de flux de travail de déploiement en entreprise existent pour remédier à cette situation, ils ne sont fondamentalement qu'une solution de fortune pour traiter un problème d'ordre architectural : le couplage particulièrement étroit entre les divers composants et services. Mais un jour ou l'autre, il deviendra impératif de trouver une solution à ce couplage étroit. L'objectif à terme est que les services puissent être déployés indépendamment les uns des autres, sans que cela ne nécessite une quelconque orchestration.

Une telle approche nécessite généralement une conception minutieuse afin de garantir que chaque service sera en mesure d'assurer la rétrocompatibilité. Ainsi, il ne sera pas nécessaire de procéder à la mise à niveau immédiate des clients du service pour éviter que l'accès leur soit refusé. Ils pourront être mis à niveau indépendamment par la suite. Des techniques telles que la gestion des versions d'API peuvent vous aider à contourner des problèmes de cet ordre. Il est également important de veiller à ce que les services puissent continuer à fonctionner (certaines fonctionnalités pouvant être temporairement indisponibles), même s'ils ne peuvent pas se connecter aux autres services dont ils dépendent. Cette conception est particulièrement adaptée aux systèmes distribués, car elle permet d'éviter les défaillances en cascade. Dans son livre "Release It!", Michael Nygard décrit un certain nombre de modèles de conception bien adaptés aux systèmes distribués, comme les disjoncteurs. Sachez que vous avez même la possibilité de découpler les mises à niveau des bases de données des services dont elles dépendent en appliquant un schéma de propagation parallèle du changement.

Composants qui ne sont pas conçus pour l'automatisation

Troisième problème assez courant : les composants qui ne sont pas conçus pour l'automatisation. Tout processus de déploiement nécessitant une connexion à une console et une interaction manuelle avec cette dernière (via des clics, par exemple) doit faire l'objet d'une amélioration. Aujourd'hui, la plupart des plates-formes (y compris Google Cloud) proposent une API que votre script de déploiement peut utiliser. Si ce n'est pas le cas, vous devez faire preuve de créativité pour éviter les interventions manuelles de cet ordre. Vous pouvez par exemple identifier la base de données ou le fichier de configuration utilisé par votre outil et apporter directement les modifications nécessaires. Sinon, vous pouvez remplacer l'outil par une solution équivalente disposant d'une API.

Mauvaise collaboration entre les équipes

Le dernier problème se présente lorsque les équipes de développement et d'exploitation informatique ne parviennent pas à se synchroniser. Cette absence de synchronisation peut prendre plusieurs formes. Par exemple, les développeurs peuvent utiliser une méthode de déploiement alors que l'équipe d'exploitation informatique en utilise une autre. Autre exemple, si les environnements sont configurés différemment, vous augmentez considérablement le risque que le processus de déploiement soit exécuté manuellement par l'équipe d'exploitation informatique, ce qui peut provoquer des incohérences et des erreurs. Le processus d'automatisation des déploiements doit être créé conjointement par les équipes de développement et d'exploitation informatique. Cette approche garantit que les deux équipes sont à même de comprendre, de gérer et de faire évoluer l'automatisation des déploiements.

Méthodes pour améliorer l'automatisation des déploiements

La première étape consiste à documenter le processus de déploiement existant dans un outil commun auquel les développeurs et l'équipe d'exploitation peuvent accéder. Il peut s'agir de Google Docs ou d'un wiki, par exemple. Ensuite, les équipes doivent progressivement tenter de simplifier et automatiser le processus de déploiement. Cette approche comprend généralement les opérations suivantes :

  • Générer vos packages de code dans l'optique du déploiement
  • Créer des machines virtuelles ou des conteneurs préconfigurés
  • Automatiser le déploiement et la configuration des intergiciels
  • Copier des packages ou des fichiers dans l'environnement de production
  • Redémarrer des serveurs, des applications ou des services
  • Générer des fichiers de configuration à partir de modèles
  • Effectuer des tests de déploiement automatisé pour s'assurer que le système fonctionne et est correctement configuré
  • Exécuter des procédures de test
  • Développer des scripts pour automatiser la migration de bases de données

Efforcez-vous de supprimer les étapes manuelles, de mettre en œuvre l'idempotence et l'indépendance vis-à-vis d'un quelconque ordre dans la mesure du possible, et essayez d'exploiter au maximum les capacités de votre plate-forme d'infrastructure. Rappelez-vous à chaque instant que l'automatisation des déploiements doit être aussi simple que possible.

Méthodes de mesure de l'automatisation du déploiement

Mesurer le degré d'automatisation d'un déploiement est relativement simple.

  • Comptez le nombre d'étapes manuelles dans votre processus de déploiement. Tentez de supprimer systématiquement ces étapes. Le nombre d'étapes manuelles augmente le temps de déploiement et les possibilités d'erreur.
  • Mesurez le niveau (ou le pourcentage) d'automatisation dans votre pipeline de déploiement. Vous devez œuvrer à augmenter continuellement ce niveau.
  • Déterminez le temps perdu à cause des retards se produisant dans le pipeline de déploiement. Lorsque vous tentez de réduire ces retards, essayez d'identifier où et pourquoi le code présente des ralentissements ou des blocages dans votre pipeline de déploiement.

Étapes suivantes