Pipelines de diffusion continue avec Spinnaker et Google Kubernetes Engine

Ce tutoriel vous montre comment créer un pipeline de diffusion continue à l'aide de Google Kubernetes Engine, Cloud Source Repositories, Cloud Build et Spinnaker. Après avoir créé un exemple d'application, vous allez configurer ces services de sorte qu'ils conçoivent, testent et déploient le pipeline automatiquement. Lorsque vous modifiez le code de l'application, ces modifications amènent le pipeline de diffusion continue à répéter automatiquement ces opérations (conception, test et déploiement) pour la nouvelle version.

Architecture du pipeline

architecture du pipeline

Afin de diffuser des mises à jour d'application en continu pour vos utilisateurs, vous devez mettre en place un processus automatisé qui conçoit, 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 de 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. Si vous cherchez à accélérer les itérations, 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 de 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 :

Pipeline de diffusion d'applications

Objectifs

  • Configurer un environnement en lançant Cloud Shell, en créant un cluster GKE et en configurant votre schéma de gestion des identités et des utilisateurs
  • 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
  • Déployer Spinnaker sur GKE à l'aide de Helm
  • 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 Platform (GCP), y compris :

  • GKE
  • Cloud Load Balancing
  • Cloud Build

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

Les nouveaux utilisateurs de GCP 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. Sélectionnez ou créez un projet Google Cloud Platform.

    Accéder à la page "Gérer les ressources"

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

  4. Activez GKE, Cloud Build, and Cloud Source Repositories APIs.

    Activez APIs

Configurer l'environnement

Dans cette section, vous allez configurer l'infrastructure et les identités requises pour effectuer le tutoriel.

Démarrer une instance Cloud Shell et créer un cluster GKE

Dans ce tutoriel, vous allez exécuter toutes les commandes de terminal à partir de Cloud Shell.

  1. Ouvrez Cloud Shell.

    OUVRIR Cloud Shell

  2. Créez un cluster GKE pour déployer Spinnaker et l'exemple d'application à l'aide des commandes suivantes :

    gcloud config set compute/zone us-central1-f
    
    gcloud container clusters create spinnaker-tutorial \
        --machine-type=n1-standard-2
    

Configurer la gestion des identités et des accès

Créez un compte de service Cloud Identity and Access Management (Cloud IAM) afin de transférer les autorisations vers Spinnaker et lui permettre de stocker des données dans Cloud Storage. Spinnaker stocke les données relatives aux pipelines dans Cloud Storage pour plus de fiabilité et de résilience. Si votre déploiement Spinnaker échoue de manière inattendue, vous pouvez créer en quelques minutes un déploiement identique capable d'accéder aux mêmes données de pipeline que l'original.

  1. Créez le compte de service :

    gcloud iam service-accounts create  spinnaker-account \
        --display-name spinnaker-account
    
  2. Stockez l'adresse e-mail du compte de service et l'ID de votre projet actuel dans des variables d'environnement en vue d'une utilisation ultérieure :

    export SA_EMAIL=$(gcloud iam service-accounts list \
        --filter="displayName:spinnaker-account" \
        --format='value(email)')
    export PROJECT=$(gcloud info --format='value(config.project)')
    
  3. Associez le rôle storage.admin à votre compte de service :

    gcloud projects add-iam-policy-binding \
        $PROJECT --role roles/storage.admin --member serviceAccount:$SA_EMAIL
    
  4. Téléchargez la clé du compte de service. Vous aurez besoin de cette clé par la suite lorsque vous installerez Spinnaker et que vous importerez la clé sur GKE.

    gcloud iam service-accounts keys create spinnaker-sa.json --iam-account $SA_EMAIL
    

Configurer Cloud Pub/Sub pour déclencher les pipelines Spinnaker

  1. Créez le sujet Cloud Pub/Sub pour les notifications de Container Registry. Cette commande peut échouer et générer le message d'erreur "La ressource existe déjà dans le projet", indiquant que le sujet a déjà été créé.

    gcloud beta pubsub topics create projects/$PROJECT/topics/gcr
    
  2. Créez un abonnement que Spinnaker peut lire pour recevoir des notifications de transfert d'images.

    gcloud beta pubsub subscriptions create gcr-triggers \
        --topic projects/${PROJECT}/topics/gcr
    
  3. Accordez au compte de service de Spinnaker l'accès en lecture à partir de l'abonnement gcr-triggers.

    export SA_EMAIL=$(gcloud iam service-accounts list \
        --filter="displayName:spinnaker-account" \
        --format='value(email)')
    gcloud beta pubsub subscriptions add-iam-policy-binding gcr-triggers \
        --role roles/pubsub.subscriber --member serviceAccount:$SA_EMAIL
    

Déployer Spinnaker à l'aide de Helm

Dans cette section, vous allez vous servir de Helm pour déployer Spinnaker à partir du dépôt de graphiques. Helm est un gestionnaire de packages grâce auquel vous pouvez configurer et déployer des applications Kubernetes.

Installer Helm

  1. Téléchargez et installez le fichier binaire helm :

    wget https://storage.googleapis.com/kubernetes-helm/helm-v2.10.0-linux-amd64.tar.gz
    
  2. Décompressez le fichier sur votre système local :

    tar zxfv helm-v2.10.0-linux-amd64.tar.gz
    
    cp linux-amd64/helm .
    
  3. Attribuez à Tiller, le côté serveur de Helm, le rôle d'administrateur de cluster dans votre cluster :

    kubectl create clusterrolebinding user-admin-binding --clusterrole=cluster-admin --user=$(gcloud config get-value account)
    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-admin-binding --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  4. Attribuez à Spinnaker le rôle cluster-admin afin qu'il puisse déployer des ressources sur tous les espaces de noms :

    kubectl create clusterrolebinding --clusterrole=cluster-admin --serviceaccount=default:default spinnaker-admin
    
  5. Initialisez Helm pour installer Tiller dans votre cluster :

    ./helm init --service-account=tiller
    ./helm update
  6. Vérifiez que Helm est correctement installé en exécutant la commande ci-dessous. Si tel est le cas, le client et le serveur affichent tous les deux la version v2.10.0.

    ./helm version
    Client: &version.Version{SemVer:"v2.10.0", GitCommit:"9ad53aac42165a5fadc6c87be0dea6b115f93090", GitTreeState:"clean"}
    Server: &version.Version{SemVer:"v2.10.0", GitCommit:"9ad53aac42165a5fadc6c87be0dea6b115f93090", GitTreeState:"clean"}
    

Configurer Spinnaker

  1. Créez un bucket pour que Spinnaker stocke la configuration de pipeline :

    export PROJECT=$(gcloud info \
        --format='value(config.project)')
    export BUCKET=$PROJECT-spinnaker-config
    gsutil mb -c regional -l us-central1 gs://$BUCKET
  2. Créez le fichier (spinnaker-config.yaml) décrivant la configuration relative à l'installation de Spinnaker :

    export SA_JSON=$(cat spinnaker-sa.json)
    export PROJECT=$(gcloud info --format='value(config.project)')
    export BUCKET=$PROJECT-spinnaker-config
    cat > spinnaker-config.yaml <<EOF
    gcs:
      enabled: true
      bucket: $BUCKET
      project: $PROJECT
      jsonKey: '$SA_JSON'
    
    dockerRegistries:
    - name: gcr
      address: https://gcr.io
      username: _json_key
      password: '$SA_JSON'
      email: 1234@5678.com
    
    # Disable minio as the default storage backend
    minio:
      enabled: false
    
    # Configure Spinnaker to enable GCP services
    halyard:
      spinnakerVersion: 1.10.2
      image:
        tag: 1.12.0
      additionalScripts:
        create: true
        data:
          enable_gcs_artifacts.sh: |-
            \$HAL_COMMAND config artifact gcs account add gcs-$PROJECT --json-path /opt/gcs/key.json
            \$HAL_COMMAND config artifact gcs enable
          enable_pubsub_triggers.sh: |-
            \$HAL_COMMAND config pubsub google enable
            \$HAL_COMMAND config pubsub google subscription add gcr-triggers \
              --subscription-name gcr-triggers \
              --json-path /opt/gcs/key.json \
              --project $PROJECT \
              --message-format GCR
    EOF
    

Déployer le graphique Spinnaker

  1. Déployez le graphique avec votre ensemble de configuration à l'aide de l'interface de ligne de commande Helm. L'exécution de cette commande prend généralement cinq à dix minutes.

    ./helm install -n cd stable/spinnaker -f spinnaker-config.yaml --timeout 600 \
        --version 1.1.6 --wait
  2. Au terme de cette opération, exécutez la commande ci-dessous à partir de Cloud Shell pour configurer le transfert de port vers l'UI de Spinnaker :

    export DECK_POD=$(kubectl get pods --namespace default -l "cluster=spin-deck" \
        -o jsonpath="{.items[0].metadata.name}")
    kubectl port-forward --namespace default $DECK_POD 8080:9000 >> /dev/null &
    
  3. Pour ouvrir l'UI de Spinnaker, cliquez sur Aperçu sur le Web dans Cloud Shell, puis sur Preview on port 8080 (Prévisualiser sur le port 8080).

    port8080

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

    bonjour

    spinui

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 :

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

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

    cd sample-app
    
  4. Définissez le nom d'utilisateur et l'adresse e-mail des commits Git de ce dépôt. Remplacez [EMAIL_ADDRESS] par votre adresse e-mail Git et [USERNAME] par votre nom d'utilisateur Git.

    git config --global user.email "[EMAIL_ADDRESS]"
    git config --global user.name "[USERNAME]"
    
  5. Apportez le premier commit au dépôt du code source :

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

    gcloud source repos create sample-app
    git config credential.helper gcloud.sh
    
  7. 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
    
  8. Transférez votre code vers la branche principale du nouveau dépôt :

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

    ACCÉDER À LA PAGE DU CODE SOURCE

Configurer les déclencheurs de compilation

Dans cette section, 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.

workflow Spinnaker

  1. Dans la console GCP, accédez à la section Cloud Build, puis cliquez sur Déclencheurs de compilation.

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

  2. Sélectionnez Dépôt source Cloud et cliquez sur Continuer.

  3. Dans la liste, sélectionnez le dépôt sample-app que vous venez de créer, puis cliquez sur Continuer.

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

    • Name (Nom) : sample-app-tags
    • Trigger type (Type de déclencheur) : Tag
    • Tag (regex) (Tag – expression régulière) : v.*
    • Build configuration (Configuration de la compilation) : cloudbuild.yaml
    • cloudbuild.yaml location (Emplacement du fichier cloudbuild.yaml) : cloudbuild.yaml
  5. Cliquez sur Create trigger (Créer un déclencheur).

    Créer 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 -l us-central1 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 approprié dans vos fichiers manifestes de déploiement de 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"
    

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

Configurer des pipelines de déploiement

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

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.

configurer un pipeline de déploiement

Installer la CLI de spin pour gérer Spinnaker

L'utilitaire de ligne de commande spin permet de gérer les applications et les pipelines de Spinnaker.

  1. Téléchargez la dernière version de spin.

    curl -LO https://storage.googleapis.com/spinnaker-artifacts/spin/$(curl -s https://storage.googleapis.com/spinnaker-artifacts/spin/latest)/linux/amd64/spin
    
  2. Rendez spin exécutable.

    chmod +x spin
    

Créer le pipeline de déploiement

  1. Créez une application dans Spinnaker à l'aide de spin.

    ./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 diffusion continue. Dans ce tutoriel, le pipeline est configuré de façon à détecter les images Docker précédées de la lettre "v" qui arrivent dans Container Registry.

  1. 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
    

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. Passez la souris sur l'icône jaune en forme de personne, puis cliquez sur Continue (Continuer).

    transférer aux serveurs de production

    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.

    équilibreurs de charge

  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.

    Copiez l'adresse IP de votre application

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

    backend

    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 :

    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. Notez que la couleur a été changée en bleu en raison de la modification du code et que v1.0.1 figure désormais dans le champ Version.

    backend d'application

    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

Effectuer un nettoyage

Afin d'éviter la facturation sur votre compte Google Cloud Platform des ressources utilisées lors de ce démarrage rapide, procédez comme suit :

  1. Supprimez l'installation de Spinnaker :

    ../helm delete --purge cd
    
  2. Supprimez les exemples de services d'application :

    kubectl delete -f k8s/services
    
  3. Supprimez les liaisons IAM du compte de service :

    export SA_EMAIL=$(gcloud iam service-accounts list \
        --filter="displayName:spinnaker-account" --format='value(email)')
    export PROJECT=$(gcloud info --format='value(config.project)')
    gcloud projects remove-iam-policy-binding $PROJECT --role roles/storage.admin --member serviceAccount:$SA_EMAIL
    
  4. Supprimez le compte de service :

    export SA_EMAIL=$(gcloud iam service-accounts list \
        --filter="displayName:spinnaker-account" --format='value(email)')
    gcloud iam service-accounts delete $SA_EMAIL
    
  5. Supprimez le cluster GKE :

    gcloud container clusters delete spinnaker-tutorial --zone=us-central1-f
    
  6. Supprimez le dépôt :

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

    export PROJECT=$(gcloud info --format='value(config.project)')
    export BUCKET=$PROJECT-spinnaker-config
    gsutil -m rm -r gs://$BUCKET
    
  8. 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
    
  9. Si vous avez créé la version v1.0.2 à l'étape facultative de rollback ci-dessus, supprimez cette image de conteneur :

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

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…