Pipelines de livraison continue avec Spinnaker et Google Kubernetes Engine

Ce tutoriel explique comment créer un pipeline de livraison continue à l'aide de Google Kubernetes Engine (GKE), Cloud Source Repositories, Cloud Build et Spinnaker pour Google Cloud. Après avoir créé un exemple d'application, vous allez configurer ces services pour qu'ils compilent, testent et déploient le pipeline automatiquement. Lorsque vous modifiez le code de l'application, le pipeline de diffusion continue répète automatiquement ces opérations (compilation, test et déploiement) pour la nouvelle version.

Les rapports sur l'état du DevOps identifient les fonctionnalités qui permettent d'améliorer les performances de livraison de logiciels. Ce tutoriel vous permettra d'effectuer les opérations suivantes :

Architecture du pipeline

Le schéma suivant illustre l'architecture du pipeline de diffusion continue.

Architecture de pipeline pour les développeurs et les utilisateurs.

Afin de diffuser des mises à jour d'application en continu pour vos utilisateurs, vous devez mettre en place un processus automatisé qui compile, teste et met à jour votre logiciel de manière fiable. Les modifications de code doivent automatiquement transiter par un pipeline chargé de la création de l'artefact, des tests unitaires et fonctionnels, et du déploiement en production. Dans certains cas, il peut être utile de n'appliquer une mise à jour de code qu'à un sous-ensemble d'utilisateurs. En effet, cette méthode permet de tester la mise à jour en conditions réelles avant de la propager à l'intégralité de votre base d'utilisateurs. Si l'une de ces versions Canary se révèle insatisfaisante, votre procédure automatisée doit être capable de restaurer rapidement la version avant la mise à jour.

GKE et Spinnaker vous permettent de créer un flux de diffusion continue robuste, capable de garantir le développement, la validation et la diffusion rapides de votre logiciel. Vous cherchez certainement à accélérer les itérations. Toutefois, vous devez tout d'abord vous assurer que chaque révision d'application obtienne plusieurs validations automatisées avant d'être candidate à un déploiement en production. Lorsqu'une modification donnée a été validée par le biais de l'automatisation, vous pouvez également valider l'application manuellement et effectuer des tests supplémentaires dans la version préliminaire.

Lorsque votre équipe décide que l'application est prête pour la production, il suffit qu'un membre approuve son déploiement.

Pipeline de diffusion d'applications

Dans ce tutoriel, vous allez construire le pipeline de diffusion continue illustré dans le diagramme suivant :

Architecture du pipeline de diffusion d'applications.

Les principales étapes de ce pipeline sont les suivantes :

  1. Un développeur modifie le code et le transfère dans un dépôt.

  2. Cloud Build détecte les modifications, génère l'image Docker, teste l'image et la transmet à Spinnaker.

  3. Spinnaker détecte l'image, la déploie en mode Canary et teste son déploiement. Après approbation manuelle, Spinnaker déploie l'image en production.

Objectifs

  • Configurer votre environnement en lançant Cloud Shell et en déployant Spinnaker pour Google Cloud
  • Créer un cluster GKE sur lequel déployer l'exemple d'application
  • Télécharger un exemple d'application, créer un dépôt Git et l'importer dans un dépôt Cloud Source Repositories
  • Créer une image Docker
  • Configurer des déclencheurs afin de créer des images Docker lorsque votre application est modifiée
  • Configurer un pipeline Spinnaker pour déployer votre application de manière fiable et continue sur GKE
  • Modifier le code afin de déclencher le pipeline, et observer son déploiement en production

Coûts

Ce tutoriel utilise des composants facturables de Google Cloud, dont :

  • GKE
  • Cloud Load Balancing
  • Cloud Build
  • Cloud Source Repositories
  • Container Registry

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder à la page de sélection du projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API GKE, Cloud Build, and Cloud Source Repositories.

    Activer les API

Configurer votre environnement

Dans cette section, vous allez configurer l'infrastructure requise pour mener à bien le tutoriel.

Déployer Spinnaker pour Google Cloud à l'aide de Cloud Shell

Exécutez toutes les commandes de terminal indiquées dans ce tutoriel à partir de Cloud Shell.

Spinnaker pour Google Cloud vous permet de gérer Spinnaker dans une configuration prête pour la production et optimisée pour Google Cloud. Spinnaker pour Google Cloud configure les ressources (GKE, Memorystore, buckets Cloud Storage et comptes de service), intègre Spinnaker à des services connexes tels que Cloud Build et fournit un environnement de gestion basé sur Cloud Shell pour vos installations Spinnaker, avec des outils d'aide et d'autres outils courants tels que spin et hal.

  1. Ouvrez Spinnaker pour Google Cloud dans Cloud Shell. Cette action entraîne le clonage du dépôt Spinnaker pour Google Cloud dans votre environnement Cloud Shell et le lancement des instructions d'installation détaillées.

    ACCÉDER À CLOUD SHELL

  2. Configurez Git. Si vous avez déjà configuré Git, vous pouvez ignorer cette étape.

    git config --global user.email "EMAIL_ADDRESS"
    git config --global user.name "USERNAME"
    

    Remplacez l'élément suivant :

    • EMAIL_ADDRESS : votre adresse e-mail Git
    • USERNAME : votre nom d'utilisateur Git
  3. Définissez une variable d'environnement pour définir le projet Cloud sur lequel installer Spinnaker :

    DEVSHELL_PROJECT_ID=YOUR_PROJECT_ID
    

    Remplacez YOUR_PROJECT_ID par le projet que vous avez sélectionné ou créé pour ce tutoriel.

  4. Installer Spinnaker pour Google Cloud

    PROJECT_ID=${DEVSHELL_PROJECT_ID} ~/cloudshell_open/spinnaker-for-gcp/scripts/install/setup_properties.sh
    ~/cloudshell_open/spinnaker-for-gcp/scripts/install/setup.sh
    
  5. Redémarrez Cloud Shell afin de charger les nouveaux paramètres d'environnement.

    Option de menu pour le redémarrage de Cloud Shell

  6. Connectez-vous à Spinnaker.

    ~/cloudshell_open/spinnaker-for-gcp/scripts/manage/connect_unsecured.sh
    
  7. Dans Cloud Shell, cliquez sur l'icône Web Preview (Aperçu sur le Web) et sélectionnez Preview on port 8080 (Prévisualiser sur le port 8080).

    Aperçu Web de Cloud Shell

  8. Vous devriez voir l'écran de bienvenue, suivi de l'UI de Spinnaker :

    Écran d'accueil de Spinnaker

    Interface utilisateur Spinnaker

Créer un cluster GKE pour les déploiements d'applications

Il est de pratique courante de disposer d'un cluster GKE pour les compilations, les déploiements, etc., tout en utilisant d'autres clusters GKE pour l'exécution des applications. Dans cette section, vous allez créer un autre cluster GKE, app-cluster, sur lequel déployer l'exemple d'application.

  1. Dans Cloud Shell, créez un cluster GKE :

    ZONE=us-east1-c
    gcloud config set compute/zone $ZONE
    gcloud container clusters create app-cluster \
    --machine-type=n1-standard-2
    
  2. Ajoutez le nouveau cluster GKE à Spinnaker. Les valeurs par défaut doivent normalement convenir.

    ~/cloudshell_open/spinnaker-for-gcp/scripts/manage/add_gke_account.sh
    

    Exemple de résultat et de valeurs :

    Please enter the context you wish to use to manage your GKE resources: gke_spinnaker-246920_us-east1-c_app-cluster
    Please enter the id of the project within which the referenced cluster lives: spinnaker-246920
    Please enter a name for the new Spinnaker account: app-cluster-acct
    

  3. Redéfinissez le contexte Kubernetes sur votre cluster Spinnaker :

    kubectl config use-context gke_${DEVSHELL_PROJECT_ID}_${ZONE}_spinnaker-1
    
  4. Transférez et appliquez les modifications de configuration à Spinnaker :

    ~/cloudshell_open/spinnaker-for-gcp/scripts/manage/push_and_apply.sh
    

Créer l'image Docker

Dans cette section, vous allez configurer Cloud Build pour détecter les modifications apportées au code source de votre application. Ensuite, vous allez créer une image Docker et la transférer dans Container Registry.

Créer le dépôt du code source

  1. Dans Cloud Shell, téléchargez l'exemple de code source :

    cd ~
    wget https://gke-spinnaker.storage.googleapis.com/sample-app-v4.tgz
    
  2. Décompressez le code source :

    tar xzfv sample-app-v4.tgz
    
  3. Remplacez les répertoires par le code source :

    cd sample-app
    
  4. Apportez le premier commit au dépôt du code source :

    git init
    git add .
    git commit -m "Initial commit"
    
  5. Créez un dépôt pour héberger votre code :

    gcloud source repos create sample-app
    git config credential.helper gcloud.sh
    
  6. Ajoutez votre nouveau dépôt comme dépôt à distance :

    export PROJECT=$(gcloud info --format='value(config.project)')
    git remote add origin https://source.developers.google.com/p/$PROJECT/r/sample-app
    
  7. Transférez votre code vers la branche principale du nouveau dépôt :

    git push origin master
  8. Vérifiez si vous pouvez voir le code source dans la console :

    ACCÉDER À LA PAGE DU CODE SOURCE

Configurer vos déclencheurs de compilation

Le diagramme suivant illustre le déclencheur que vous allez créer dans cette section.

Workflow Spinnaker

Vous allez configurer Cloud Build pour générer et transférer les images Docker chaque fois que vous transférerez des tags Git dans le dépôt source. Cloud Build va vérifier automatiquement votre code source, créer l'image Docker à partir du Dockerfile de votre dépôt et la transférer dans Container Registry.

  1. Dans Cloud Console, dans la section Cloud Build, cliquez sur Déclencheurs, puis sur Créer un déclencheur.

    ACCÉDER À LA PAGE DES DÉCLENCHEURS DE COMPILATION

  2. Configurez le déclencheur de la façon suivante :

    • Nom : sample-app-tags
    • Événement : sélectionnez Transférer le nouveau tag.
    • Dépôt : sample-app
    • Tag (expression régulière) : v.*
    • Configuration de la compilation : /cloudbuild.yaml
  3. Cliquez sur Créer.

    Paramètres de déclenchement à renseigner à la création d'un déclencheur.

Désormais, lorsque vous transférez un tag Git précédé de la lettre "v" vers le dépôt du code source, Cloud Build crée et transfère automatiquement votre application en tant qu'image Docker vers Container Registry.

Préparer les fichiers manifestes Kubernetes pour leur utilisation dans Spinnaker

Spinnaker a besoin d'accéder à vos fichiers manifestes Kubernetes pour pouvoir les déployer sur vos clusters. Dans cette section, vous allez créer un bucket Cloud Storage qui contiendra vos fichiers manifestes lors du processus CI dans Cloud Build. Une fois que vos fichiers manifestes sont stockés dans Cloud Storage, Spinnaker peut les télécharger et les appliquer lors de l'exécution du pipeline.

  1. Créez le bucket.

    export PROJECT=$(gcloud info --format='value(config.project)')
    gsutil mb gs://$PROJECT-kubernetes-manifests
    
  2. Activez la gestion des versions sur le bucket afin de disposer d'un historique de fichiers manifestes.

    gsutil versioning set on gs://$PROJECT-kubernetes-manifests
    
  3. Définissez l'ID de projet Google Cloud approprié dans vos fichiers manifestes de déploiement Kubernetes :

    sed -i s/PROJECT/$PROJECT/g k8s/deployments/*
    
  4. Effectuez un commit des modifications dans le dépôt :

    git commit -a -m "Set project ID"
    

Configurer des pipelines de déploiement

Maintenant que vos images sont créées automatiquement, vous devez les déployer sur le cluster Kubernetes.

Le diagramme suivant illustre les étapes du pipeline de déploiement.

Configurer un pipeline de déploiement

Pour réaliser les tests d'intégration, vous devez effectuer le déploiement dans un environnement réduit. Ensuite, si les tests sont concluants, vous devez approuver manuellement les modifications pour déployer le code sur les services de production.

Créer le pipeline de déploiement

  1. Utilisez spin pour créer une application dans Spinnaker.

    spin application save --application-name sample \
                          --owner-email example@example.com \
                          --cloud-providers kubernetes \
                          --gate-endpoint http://localhost:8080/gate
    

    Créez ensuite le pipeline de livraison continue. Dans ce tutoriel, le pipeline est configuré de façon à détecter les images Docker précédées d'un tag v qui arrivent dans Container Registry.

  2. Dans un nouvel onglet de Cloud Shell, exécutez la commande suivante dans le répertoire du code source pour importer un exemple de pipeline dans votre instance Spinnaker :

    export PROJECT=$(gcloud info --format='value(config.project)')
    sed s/PROJECT/$PROJECT/g spinnaker/pipeline-deploy.json > pipeline.json
    spin pipeline save --gate-endpoint http://localhost:8080/gate -f pipeline.json
    

Créer une image

Transférez votre première image en suivant les instructions ci-dessous :

  1. Accédez à votre dossier de code source dans Cloud Shell.
  2. Créez un tag Git :

    git tag v1.0.0
  3. Transférez le tag :

    git push --tags
  4. Dans Cloud Build, cliquez sur Historique de compilation pour vérifier que la compilation a bien été déclenchée. Si ce n'est pas le cas, vérifiez si le déclencheur a été configuré correctement à la section précédente.

    ACCÉDER À L'HISTORIQUE DE COMPILATION

    Historique de compilation

Visualiser l'exécution d'un pipeline

La configuration que vous venez de créer s'appuie sur les notifications de transfert de nouvelles images taguées pour déclencher un pipeline Spinnaker. Dans une étape précédente, vous avez transféré un tag vers Cloud Source Repositories, ce qui a amené Cloud Build à créer et à transférer votre image dans Container Registry. Vous pouvez maintenant vérifier le pipeline qui a été déclenché.

  1. Revenez à la page des pipelines en cliquant sur Pipelines.

  2. Cliquez sur Détails pour afficher plus d'informations sur la progression du pipeline. Cette section affiche l'état et les différentes étapes du pipeline de déploiement : les étapes en bleu sont en cours d'exécution, les étapes en vert ont abouti et les étapes en rouge ont échoué. Cliquez sur une étape pour en afficher les détails.

    Après trois à cinq minutes, la phase d'intégration s'achève. Vous devez approuver manuellement le pipeline pour poursuivre le déploiement.

  3. Gardez le pointeur de la souris sur Push to production (transférer en production), puis cliquez sur Continue (Continuer).

    Le déploiement se poursuit sur l'interface et le backend de production. Il est exécuté en quelques minutes.

  4. Pour afficher l'application, sélectionnez Infrastructure > Load Balancers (Équilibreurs de charge) dans l'angle supérieur droit de l'UI de Spinnaker.

    Liste déroulante Infrastructure avec l'option Équilibreurs de charge sélectionnée.

  5. Faites défiler la liste des équilibreurs de charge, puis cliquez sur Default (Par défaut), sous sample-frontend-production.

    Équilibreur de charge par défaut.

  6. Faites défiler le volet Détails situé à droite, puis copiez l'adresse IP de votre application en cliquant sur le bouton du presse-papiers à côté de l'adresse IP indiquée sous Ingress (Entrée). Le lien IP d'entrée de l'interface utilisateur de Spinnaker utilise HTTPS par défaut, mais l'application est configurée pour utiliser HTTP.

    Volet Détails comportant l'adresse IP de votre application.

  7. Collez l'adresse dans votre navigateur pour afficher la version de production de l'application.

    Version de production de l'application.

    Vous avez désormais déclenché manuellement le pipeline afin de créer, tester et déployer votre application.

Déclencher le pipeline suite à des modifications de code

Dans cette section, vous allez tester le pipeline de bout en bout. Pour ce faire, vous allez modifier le code, transférer un tag Git et observer l'exécution du pipeline. Le transfert d'un tag Git qui commence par la lettre "v" entraîne la création, par Cloud Build, d'une image Docker et son transfert dans Container Registry. Spinnaker détecte que le nouveau tag de l'image commence par un "v" et déclenche un pipeline afin de déployer l'image sur des éléments Canary, d'exécuter des tests et d'envoyer cette même image sur tous les pods du déploiement.

  1. Remplacez la couleur orange de l'application par la couleur bleu :

    cd ~/sample-app
    sed -i 's/orange/blue/g' cmd/gke-info/common-service.go
    
  2. Taguez votre modification, puis transférez-la dans le dépôt du code source :

    git commit -a -m "Change color to blue"
    git tag v1.0.1
    git push --tags
    
  3. Regardez la nouvelle version apparaître dans l'historique de compilation de Cloud Build.

  4. Cliquez sur Pipelines. Vous pouvez voir que le pipeline commence à déployer l'image.

  5. Observez les déploiements Canary. Lorsque le déploiement est suspendu, commencez à actualiser l'onglet contenant votre application en attendant de passer en production. Quatre de vos backends exécutent la version précédente de votre application, tandis qu'un seul backend exécute la version Canary. La nouvelle version de votre application doit s'afficher en bleu toutes les 10 actualisations.

  6. À la fin de la phase de test, retournez dans l'onglet Spinnaker et approuvez le déploiement.

  7. Une fois le pipeline terminé, votre application ressemble à la capture d'écran suivante. Le champ Version indique désormais v1.0.1.

    Version de production de l'application mise à jour.

    Vous venez de déployer votre application dans l'ensemble de l'environnement de production.

  8. Vous pouvez éventuellement annuler cette modification en rétablissant le commit précédent. Lors d'un rollback, un nouveau tag ((v1.0.2) est ajouté et transféré via le même pipeline que celui ayant servi à déployer la version v1.0.1 :

    git revert v1.0.1
    git tag v1.0.2
    git push --tags

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform :

  1. Supprimez Spinnaker pour Google Cloud :

    cd ~
    ~/cloudshell_open/spinnaker-for-gcp/scripts/manage/generate_deletion_script.sh
    ~/cloudshell_open/spinnaker-for-gcp/scripts/manage/delete-all_${DEVSHELL_PROJECT_ID}_spinnaker-1_spinnaker-1.sh
    
  2. Supprimez le cluster GKE :

    gcloud container clusters delete app-cluster --zone=us-east1-c
    
  3. Supprimez le dépôt :

    gcloud source repos delete sample-app
    
  4. Supprimez le bucket :

    export PROJECT=$(gcloud info --format='value(config.project)')
    export BUCKET=$PROJECT-kubernetes-manifests
    gsutil -m rm -r gs://$BUCKET
    
  5. Supprimez les images de conteneur :

    export PROJECT=$(gcloud info --format='value(config.project)')
    gcloud container images delete gcr.io/$PROJECT/sample-app:v1.0.0
    gcloud container images delete gcr.io/$PROJECT/sample-app:v1.0.1
    
  6. Si vous avez créé v1.0.2 lors de l'étape de rollback facultative ci-dessus, supprimez cette image de conteneur :

    gcloud container images delete gcr.io/$PROJECT/sample-app:v1.0.2
    

Étape suivante