Automatisez vos déploiements

Last reviewed 2023-07-17 UTC

Ce document du framework d'architecture Google Cloud présente les bonnes pratiques pour automatiser vos compilations, vos tests et vos déploiements.

L'automatisation vous aide à standardiser les compilations, les tests et les déploiements en éliminant les erreurs causées par l'humain pour des processus répétés tels que les mises à jour de code. Cette section explique comment utiliser divers contrôles et garde-fous à des fins d'automatisation. Un processus standardisé contrôlé par la machine permet de garantir l'application sécurisée des déploiements. Il fournit également un mécanisme permettant de restaurer les déploiements précédents sans que cela n'affecte considérablement l'expérience utilisateur.

Stocker votre code dans les dépôts de code central

Stockez votre code dans des dépôts de code centralisés, qui comprennent un système de contrôle des versions avec tags et offrent la possibilité d'annuler les modifications de code. Le contrôle des versions vous permet d'organiser les fichiers et de contrôler l'accès, les mises à jour et la suppression entre les différentes équipes et organisations.

Pour les différentes étapes de développement, versionnez et ajoutez des libellés aux dépôts si nécessaire. Par exemple, les libellés peuvent être test, dev et prod.

Dans Google Cloud, vous pouvez stocker votre code dans Cloud Source Repositories, le versionner et en gérer l'intégration à d'autres produits Google Cloud. Si vous créez des applications conteneurisées, utilisez Artifact Registry, un registre géré pour les conteneurs.

Pour plus d'informations sur le contrôle des versions, consultez la page Contrôle des versions. Pour en savoir plus sur la mise en œuvre du développement à branche unique avec vos dépôts, consultez la page Développement à branche unique.

Utiliser l'intégration et le déploiement continus (CI/CD)

Automatisez vos déploiements à l'aide d'une approche d'intégration et de déploiement continus (CI/CD). Une approche CI/CD est une combinaison de pipelines que vous configurez et de processus que votre équipe de développement doit suivre.

Une approche CI/CD augmente la vitesse de déploiement en améliorant la productivité de votre équipe de développement logiciel. Cette approche permet aux développeurs d'apporter des modifications plus petites et plus fréquentes, qui sont testées minutieusement tout en réduisant le temps nécessaire à leur déploiement.

Dans le cadre de votre approche CI/CD, automatisez toutes les étapes de création, de test et de déploiement de votre code. Exemple :

  • Chaque fois que du nouveau code est validé (commit) dans le dépôt, appelez automatiquement le pipeline de compilation et de test.
  • Automatisez les tests d'intégration.
  • Automatisez votre déploiement afin que les modifications soient effectives une fois que votre compilation satisfait des critères de test spécifiques.

Dans Google Cloud, vous pouvez utiliser Cloud Build et Cloud Deploy pour vos pipelines CI/CD.

Utilisez Cloud Build pour définir les dépendances et les versions que vous pouvez utiliser pour le packaging et la création d'un package d'application. Mettez à jour votre configuration de build pour vous assurer que tous vos builds sont cohérents et que vous pouvez effectuer un rollback vers une configuration précédente si nécessaire.

Utilisez Cloud Deploy (bêta) pour déployer vos applications dans des environnements spécifiques sur Google Cloud et gérer vos pipelines de déploiement.

Pour en savoir plus sur la mise en œuvre de la CI/CD, consultez les pages Intégration continue et Automatisation des déploiements.

Provisionner et gérer votre infrastructure à l'aide de l'infrastructure en tant que code

L'infrastructure en tant que code consiste à utiliser un modèle descriptif pour gérer l'infrastructure, telle que les VM, et les configurations, telles que les règles de pare-feu. L'infrastructure en tant que code vous permet d'effectuer les opérations suivantes :

  • Créez automatiquement vos ressources cloud, y compris les environnements de déploiement ou de test pour votre pipeline CI/CD.
  • Traitez les modifications d'infrastructure de la même manière que les modifications d'application. Par exemple, assurez-vous que les modifications apportées à la configuration sont examinées, testées et qu'elles peuvent être auditées.
  • Ayez une version unique de votre infrastructure cloud.
  • Répliquez votre environnement cloud selon vos besoins.
  • Si nécessaire, effectuez un rollback vers une configuration précédente.

Ce concept d'Infrastructure as Code s'applique également aux projets dans Google Cloud. Vous pouvez utiliser cette approche pour définir des ressources telles que la connectivité de VPC partagé ou l'accès IAM (Identity and Access Management) dans vos projets. Pour obtenir un exemple de cette approche, consultez le module Terraform de la fabrique de projets Google Cloud.

Des outils tiers, tels que Terraform, vous aident à créer automatiquement votre infrastructure sur Google Cloud. Pour en savoir plus, consultez la page Gérer une infrastructure en tant que code avec Terraform, Cloud Build et GitOps.

Songez à utiliser les fonctionnalités Google Cloud, par exemple :privilèges du projet,règles de conservation Cloud Storage et verrous de bucket Cloud Storage pour protéger les ressources critiques contre toute suppression accidentelle ou malveillante.

Intégrer des tests tout au long du cycle de livraison des logiciels

Les tests sont essentiels au lancement réussi de votre logiciel. Les tests continus aident les équipes à créer plus rapidement des logiciels de haute qualité et à en améliorer la stabilité.

Types de test :

  • Tests unitaires. Les tests unitaires sont rapides et vous permettent d'effectuer des déploiements rapides. Traiter les tests unitaires dans le cadre de la codebase et les inclure dans le processus de compilation.
  • Tests d'intégration. Les tests d'intégration sont importants, en particulier pour les charges de travail conçues pour évoluer et dépendre de plusieurs services. Ces tests peuvent devenir complexes lorsque vous testez l'intégration avec des services interconnectés.
  • Tests système. Les tests du système sont longs et complexes. Toutefois, ils vous aident à identifier les cas spéciaux et à résoudre les problèmes avant le déploiement.
  • Autres tests. Vous devez exécuter d'autres tests, y compris des tests statiques, des tests de charge, des tests de sécurité, des tests de validation des règles, etc… Exécutez ces tests avant de déployer votre application en production.

Pour intégrer les tests, procédez comme suit :

  • Effectuer tous les types de tests continus tout au long du cycle de livraison des logiciels.
  • Automatisez ces tests et incluez-les dans le pipeline CI/CD. Vous devez faire échouer votre pipeline en cas d'échec de l'un des tests.
  • Mettez à jour les tests et ajoutez-en de nouveaux en continu pour améliorer et maintenir l'état opérationnel de votre déploiement.

Pour vos environnements de test :

  • Utilisez des projets Google Cloud distincts pour chaque environnement de test. Pour chaque application, utilisez un environnement de projet distinct. Cette séparation permet une distinction claire entre les ressources de l'environnement de production et les ressources de vos environnements inférieurs. Cette séparation permet de garantir que les modifications d'un environnement n'affectent pas accidentellement les autres environnements.
  • Automatisez la création d'environnements de test. Une manière d'effectuer cette automatisation consiste à utiliser l'infrastructure en tant que code.
  • Utilisez un environnement de production synthétique pour tester les modifications. Cet environnement fournit un environnement similaire à l'environnement de production pour tester votre application et effectuer différents types de tests sur vos charges de travail, y compris des tests de bout en bout et des tests de performances.

Pour en savoir plus sur la mise en œuvre des tests continus, consultez la page Automatiser les tests.

Lancer progressivement les déploiements

Choisissez votre stratégie de déploiement en fonction de paramètres importants, tels que la perturbation minimale des utilisateurs finaux, les mises à jour progressives, les stratégies de rollback et les stratégies de test A/B. Pour chaque charge de travail, évaluez ces exigences et choisissez une stratégie de déploiement utilisant des techniques éprouvées, telles que les mises à jour progressives, les déploiements bleu-vert et les déploiements Canary.

Ne laissez les processus CI/CD effectuer et appliquer des modifications que dans votre environnement de production.

Envisagez d'utiliser une infrastructure immuable. Une infrastructure immuable est une infrastructure qui n'est ni modifiée, ni mise à jour. Lorsque vous devez déployer un nouveau code ou modifier toute autre configuration dans votre environnement, vous devez remplacer l'intégralité de l'environnement (un ensemble de VM ou de pods, par exemple) par le nouvel environnement. Les déploiements bleu-vert sont un exemple d'infrastructure immuable.

Nous vous recommandons d'effectuer des tests en version Canary afin de détecter d'éventuelles erreurs dans votre système lorsque vous déployez des modifications. Ce type d'observation est plus facile si vous disposez d'un système de surveillance et d'alerte robuste. Pour effectuer des tests A/B ou des tests en version Canary, vous pouvez utiliser les groupes d'instances gérés de Google Cloud. Vous pouvez ensuite effectuer un déploiement lent ou une restauration si nécessaire.

Envisagez d'automatiser les déploiements et de gérer votre pipeline de déploiement à l'aide de Cloud Deploy. Vous pouvez également utiliser de nombreux outils tiers, tels que Spinnaker et Tekton, sur Google Cloud pour les déploiements automatisés et pour créer des pipelines de déploiement.

Restaurer facilement les versions précédentes

Définissez votre stratégie de restauration dans le cadre de votre stratégie de déploiement. Assurez-vous de pouvoir effectuer un rollback d'un déploiement ou d'une configuration d'infrastructure vers une version précédente du code source. La restauration d'un déploiement stable précédent est une étape importante de la gestion des incidents, à la fois pour la fiabilité et la sécurité.

Veillez également à restaurer l'environnement dans l'état dans lequel il se trouvait avant le début du processus de déploiement. Cela peut inclure :

  • Possibilité d'annuler toutes les modifications de code dans votre application.
  • Possibilité d'annuler les modifications de configuration apportées à l'environnement.
  • L'utilisation d'une infrastructure immuable pour s'assurer que les déploiements ne modifient pas l'environnement Ces pratiques facilitent l'annulation des modifications de configuration.

Surveiller vos pipelines CI/CD

Pour garantir le bon fonctionnement de votre processus automatisé de compilation, de test et de déploiement, surveillez vos pipelines CI/CD. Définissez des alertes qui indiquent quand un pipeline échoue. Chaque étape de votre pipeline doit écrire des entrées de journalisation appropriées afin que votre équipe puisse effectuer une analyse des causes fondamentales en cas d'échec d'un pipeline.

Dans Google Cloud, tous les services CI/CD sont intégrés à Google Cloud Observability. Exemple :

Pour en savoir plus sur la surveillance et la journalisation, consultez la page Configurer la surveillance, les alertes et la journalisation.

Déployer des applications en toute sécurité

Consultez la section Déployer des applications en toute sécurité dans la catégorie "Sécurité, conformité et confidentialité" du framework d'architecture.

Établir des consignes de gestion pour les versions

Pour aider vos ingénieurs à éviter les erreurs et pour assurer des livraisons de logiciels rapides, assurez-vous que vos consignes de gestion pour la publication de nouvelles versions logicielles sont clairement documentées.

Les ingénieurs de versions supervisent la compilation et la livraison des logiciels. Le système d'ingénierie des versions est guidé par quatre pratiques :

  • Mode libre-service. Permet de définir des consignes pour aider les ingénieurs logiciels à éviter les erreurs courantes. Ces consignes sont généralement codifiées dans des processus automatisés.

  • Versions fréquentes. Une rapidité améliorée facilite le dépannage et la résolution des problèmes. Les versions fréquentes reposent sur des tests unitaires automatisés.

  • Builds hermétiques. Permettent d'assurer la cohérence avec vos outils de compilation. Mettez à jour les compilateurs de build qui vous permettent de créer des builds aujourd'hui par rapport à ceux que vous utilisiez il y a un mois.

  • Application des règles. Toutes les modifications nécessitent une vérification du code, idéalement sous la forme d'un ensemble de consignes et de règles destinées à la sécurité. L'application des règles améliore la vérification du code, le dépannage et les tests de nouvelle version.

Étape suivante