Pipelines de livraison continue avec Spinnaker et Kubernetes Engine

1 heure 30 minutes 7 crédits

GSP114

Google Cloud – Ateliers adaptés au rythme de chacun

Dans cet atelier, vous allez découvrir comment créer un pipeline de livraison continue à l'aide de Google Kubernetes Engine, Google Cloud Source Repositories, Google Cloud Container Builder et Spinnaker. Après avoir créé un exemple d'application, vous allez configurer ces services pour qu'ils conçoivent, testent et déploient le pipeline de façon automatique. Lorsque vous modifierez le code de l'application, le pipeline de livraison continue répétera automatiquement ces opérations (conception, test et déploiement) pour la nouvelle version.

Objectifs

Configurer votre environnement en lançant Google Cloud Shell, en créant un cluster Kubernetes Engine et en paramétrant 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 Google Cloud Source Repositories
Déployer Spinnaker sur Kubernetes Engine à l'aide de Helm
Créer votre image Docker
Configurer des déclencheurs afin de créer des images Docker lorsque votre application est modifiée
Configurer un pipeline Spinnaker afin de déployer votre application sur Kubernetes Engine de manière fiable et continue
Modifier le code afin de déclencher le pipeline, et observer son déploiement en production

Architecture du pipeline

Pour livrer en continu vos mises à jour d'application à vos utilisateurs, vous devez vous doter d'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 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 mise à jour.

Kubernetes Engine et Spinnaker vous permettent de créer un flux de livraison continue robuste, capable de veiller à ce que votre logiciel soit développé, validé et diffusé rapidement. Vous cherchez certainement à accélérer les itérations. Toutefois, vous devez tout d'abord vous assurer que chaque révision d'application obtient plusieurs validations automatisées avant d'être candidate à un déploiement en production. Lorsqu'une modification donnée a été approuvée automatiquement, vous pouvez également valider manuellement l'application et procéder à d'autres tests avant son lancement.

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 livraison d'application

Dans cet atelier, vous allez construire un pipeline de livraison continue, comme illustré sur le schéma suivant.

Prérequis

Configuration de Qwiklabs

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;

Remarque : Ouvrez une fenêtre de navigateur en mode incognito/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

Démarrer l'atelier et se connecter à la console Google Cloud

Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, un pop-up s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau Détails concernant l'atelier, qui contient les éléments suivants :
- Le bouton Ouvrir la console Google
- Le temps restant
- Les identifiants temporaires que vous devez utiliser pour cet atelier
- Des informations complémentaires vous permettant d'effectuer l'atelier
Cliquez sur Ouvrir la console Google. L'atelier lance les ressources, puis ouvre la page Se connecter dans un nouvel onglet.

Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.
Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.
Si nécessaire, copiez le nom d'utilisateur inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue Se connecter. Cliquez sur Suivant.
Copiez le mot de passe inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue de bienvenue. Cliquez sur Suivant.
Important : Vous devez utiliser les identifiants fournis dans le panneau de gauche. Ne saisissez pas vos identifiants Google Cloud Skills Boost. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.
Accédez aux pages suivantes :
- Acceptez les conditions d'utilisation.
- N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
- Ne vous inscrivez pas aux essais offerts.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Vous pouvez afficher le menu qui contient la liste des produits et services Google Cloud en cliquant sur le menu de navigation en haut à gauche. Icône du menu de navigation

Activer Cloud Shell

Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

Cliquez sur Activer Cloud Shell en haut de la console Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Le résultat contient une ligne qui déclare YOUR_PROJECT_ID (VOTRE_ID_PROJET) pour cette session :

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

(Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

Cliquez sur Autoriser.
Vous devez à présent obtenir le résultat suivant :

Résultat :

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

(Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = <ID_Projet>

Exemple de résultat :

[core] project = qwiklabs-gcp-44776a13dea667a6

Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Configurer votre environnement

Configurez l'infrastructure et les identités requises pour cet atelier. Commencez par créer un cluster Kubernetes Engine permettant de déployer Spinnaker et l'exemple d'application.

Définissez la zone de calcul par défaut :

gcloud config set compute/zone us-central1-f

Créez un cluster Kubernetes Engine à l'aide de l'exemple d'application Spinnaker :

gcloud container clusters create spinnaker-tutorial \
    --machine-type=n1-standard-2

La création d'un cluster prend entre cinq et dix minutes. Attendez que votre cluster soit provisionné avant de continuer.

Une fois le déploiement terminé, vous obtenez un rapport comprenant les informations suivantes : le nom, l'emplacement, la version, l'adresse IP, le type de machine, la version de nœud, le nombre de nœuds et l'état du cluster qui indique que le cluster est en cours d'exécution.

Configurer la gestion de l'authentification 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 des 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 pouvant accéder aux mêmes données de pipeline que l'original.

Importez votre script de démarrage dans un bucket Cloud Storage en suivant les instructions ci-dessous :

Créez le compte de service :

gcloud iam service-accounts create spinnaker-account \
    --display-name spinnaker-account

Stockez l'adresse e-mail du compte de service et l'ID de votre projet 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)')

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

Téléchargez la clé du compte de service. Lors d'une étape ultérieure, vous installerez Spinnaker et importerez cette clé dans Kubernetes Engine :

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

(Résultat)

created key [12f224e036437704b91a571792462ca6fc4cd438] of type [json] as [spinnaker-sa.json] for [spinnaker-account@qwiklabs-gcp-gcpd-f5e16da10e5d.iam.gserviceaccount.com]

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

Créez le sujet Cloud Pub/Sub pour les notifications de Container Registry :

gcloud pubsub topics create projects/$PROJECT/topics/gcr

Créez un abonnement que Spinnaker peut lire pour recevoir des notifications de transfert d'images :

gcloud pubsub subscriptions create gcr-triggers \
    --topic projects/${PROJECT}/topics/gcr

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

Tester la tâche terminée

Cliquez sur Check my progress (Vérifier ma progression) pour vérifier la tâche exécutée. Si vous avez réussi à configurer l'environnement, vous verrez une note d'évaluation s'afficher.

Configurer votre environnement

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 Charts. Helm est un gestionnaire de packages qui vous permet de configurer et de déployer des applications Kubernetes.

Installer Helm

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

wget https://get.helm.sh/helm-v3.1.1-linux-amd64.tar.gz

Décompressez le fichier sur votre système local :

tar zxfv helm-v3.1.1-linux-amd64.tar.gz

cp linux-amd64/helm .

Accordez à Helm le rôle cluster-admin dans votre cluster :

kubectl create clusterrolebinding user-admin-binding \
    --clusterrole=cluster-admin --user=$(gcloud config get-value account)

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

Ajouter les déploiements de charts stables aux dépôts utilisables de Helm (inclut Spinnaker) :

./helm repo add stable https://charts.helm.sh/stable
./helm repo update

Configurer Spinnaker

Toujours dans Cloud Shell, 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

Exécutez la commande suivante pour créer un fichier spinnaker-config.yaml décrivant la façon dont Helm installe 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.19.4
  image:
    repository: us-docker.pkg.dev/spinnaker-community/docker/halyard
    tag: 1.32.0
    pullSecrets: []
  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 chart Spinnaker

Déployez le chart avec votre ensemble de configuration à l'aide de l'interface de ligne de commande Helm :

./helm install -n default cd stable/spinnaker -f spinnaker-config.yaml \
           --version 2.0.0-rc9 --timeout 10m0s --wait

L'installation prend généralement 5 à 8 minutes.

Au terme de cette opération, exécutez la commande ci-dessous pour configurer le transfert de port de Cloud Shell vers 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 &

Pour ouvrir l'interface utilisateur de Spinnaker, cliquez sur l'icône Aperçu sur le Web en haut de la fenêtre Cloud Shell et sélectionnez Preview on port 8080 (Prévisualiser sur le port 8080).

L'écran de bienvenue s'affiche, suivi de l'interface utilisateur de Spinnaker :

Laissez cet onglet ouvert. Il vous permettra d'accéder à l'interface utilisateur de Spinnaker.

Tester la tâche terminée

Cliquez sur Check my progress (Vérifier ma progression) pour vérifier la tâche exécutée. Si vous avez réussi à déployer le chart Spinnaker dans Kubernetes à l'aide de Helm, vous verrez une note d'évaluation s'afficher.

Déployer le chart Spinnaker dans Kubernetes à l'aide de Helm

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

Dans l'onglet Cloud Shell, téléchargez le code source de l'exemple d'application :

gsutil -m cp -r gs://spls/gsp114/sample-app.tar .

Décompressez le code source :

mkdir sample-app
tar xvf sample-app.tar -C ./sample-app

Remplacez les répertoires par le code source :

cd sample-app

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

git config --global user.email "$(gcloud config get-value core/account)"

git config --global user.name "[USERNAME]"

Apportez le premier commit au dépôt du code source :

git init

git add .

git commit -m "Initial commit"

Créez un dépôt pour héberger votre code :

gcloud source repos create sample-app

Vous pouvez ignorer le message "you may be billed for this repository" (ce dépôt pourra vous être facturé).

git config credential.helper gcloud.sh

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

Transférez votre code vers la branche principale du nouveau dépôt :

git push origin master

Vérifiez que votre code source se trouve bien dans la console en cliquant sur le menu de navigation, puis sur Source Repositories (Dépôts sources).

Cliquez sur sample-app.

Configurer vos déclencheurs de compilation

Configurez Container Builder de sorte que vos images Docker soient créées et transférées à chaque fois que vous envoyez des tags Git vers votre dépôt source. Container Builder vérifie automatiquement votre code source, crée l'image Docker à partir du fichier Dockerfile de votre dépôt et transfère cette image à Google Cloud Container Registry.

Dans la console Google Cloud Platform, accédez au menu de navigation, puis cliquez sur Cloud Build > Triggers (Cloud Build > Déclencheurs).
Cliquez sur Create trigger (Créer un déclencheur).

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

Name (Nom) : sample-app-tags
Event (Événement) : Push new tag (Transférer le nouveau tag)
Sélectionnez le dépôt sample-app que vous venez de créer.
Tag : v1.*
Build configuration (Configuration de la compilation) : Cloud Build configuration file (yaml or json)
Cloud Build configuration file location (Emplacement du fichier de configuration Cloud Build) : /cloudbuild.yaml

Cliquez sur CREATE (CRÉER).

Désormais, lorsque vous envoyez un tag Git précédé de la lettre "v" vers le dépôt du code source, Container Builder 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.

Créez le bucket :

export PROJECT=$(gcloud info --format='value(config.project)')

gsutil mb -l us-central1 gs://$PROJECT-kubernetes-manifests

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

Définissez l'ID de projet approprié dans vos fichiers manifestes de déploiement de Kubernetes :

sed -i s/PROJECT/$PROJECT/g k8s/deployments/*

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 :

Dans Cloud Shell, toujours dans le répertoire sample-app, créez un tag Git :

git tag v1.0.0

Transférez le tag :

git push --tags

(Résultat)

To https://source.developers.google.com/p/qwiklabs-gcp-ddf2925f84de0b16/r/sample-app
* [new tag]      v1.0.0 -> v1.0.0

Accédez à Cloud Console. Toujours dans Cloud Build, cliquez sur History (Historique) dans le volet de gauche pour vérifier que la compilation a bien été déclenchée. Si ce n'est pas le cas, vérifiez que le déclencheur a été configuré correctement à la section précédente.

Restez sur cette page et attendez que la compilation soit terminée avant de passer à la section suivante.

Tester la tâche terminée

Cliquez sur Check my progress (Vérifier ma progression) pour vérifier la tâche exécutée. Si vous avez réussi à compiler l'image Docker, vous verrez une note d'évaluation s'afficher.

Compilation de l'image Docker

Configurer des pipelines de déploiement

Vos images sont désormais créées automatiquement. Vous devez maintenant 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.

Installer la CLI spin pour gérer Spinnaker

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

Téléchargez la version 1.14.0 de spin :

curl -LO https://storage.googleapis.com/spinnaker-artifacts/spin/1.14.0/linux/amd64/spin

Rendez spin exécutable :

chmod +x spin

Créer le pipeline de déploiement

Dans Spinnaker, créez une application nommée "sample" à l'aide de "spin". Définissez l'adresse e-mail du propriétaire pour l'application dans Spinnaker :

./spin application save --application-name sample \
                        --owner-email "$(gcloud config get-value core/account)" \
                        --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 avec un tag précédé de la lettre "v" qui arrivent dans Container Registry.

Dans le répertoire sample-app du code source, exécutez la commande suivante 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

Déclencher manuellement et visualiser l'exécution de votre 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. Vérifiez le pipeline en exécutant la commande suivante : manually trigger.

Dans l'interface utilisateur de Spinnaker, cliquez sur Applications en haut de l'écran pour afficher la liste des applications gérées. Votre application se nomme sample. Si l'application sample ne s'affiche pas, essayez d'actualiser l'onglet Applications de Spinnaker.

Cliquez sur sample pour afficher le déploiement de votre application.
Cliquez sur Pipelines en haut de la page pour afficher l'état du pipeline de votre application.
Cliquez sur Start Manual Execution (Démarrer l'exécution manuelle) pour déclencher le pipeline pour la première fois.

Cliquez sur Run (Exécuter).
Cliquez sur Execution Details (Détails de l'exécution) pour afficher plus d'informations sur la progression du pipeline.

La barre de progression indique 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. Le pipeline a besoin d'une autorisation manuelle pour poursuivre le déploiement.

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

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

Faites défiler la liste des équilibreurs de charge, puis cliquez sur "Default" (Par défaut), sous service sample-frontend-production. Les détails de votre équilibreur de charge s'affichent dans la partie droite de la page. Si ce n'est pas le cas, actualisez votre navigateur.
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.

Collez l'adresse dans un nouvel onglet de navigateur pour afficher l'application. La version Canary va peut-être s'afficher. Si vous actualisez, la version de production de l'application s'affiche également.

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

Tester la tâche terminée

Cliquez sur Check my progress (Vérifier ma progression) pour vérifier la tâche exécutée. Si vous avez réussi à créer des équilibreurs de charge pour le service, vous verrez une note d'évaluation s'afficher.

Créer des équilibreurs de charge pour le service

Tester la tâche terminée

Cliquez sur Check my progress (Vérifier ma progression) pour vérifier la tâche exécutée. Si vous avez réussi à déployer une image en production, vous verrez une note d'évaluation s'afficher.

Déployer une image en production

Déclencher le pipeline suite à des modifications de code

Maintenant, testez le pipeline de bout en bout : modifiez le code, transférez un tag Git et observez l'exécution du pipeline. Le transfert d'un tag Git qui commence par la lettre "v" entraîne la création, par Container Builder, d'une nouvelle image Docker et son transfert à 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 test, d'exécuter des tests et d'envoyer cette même image sur tous les pods du déploiement.

Dans votre répertoire sample-app, remplacez la couleur orange de l'application par la couleur bleue :

sed -i 's/orange/blue/g' cmd/gke-info/common-service.go

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

Dans la console, accédez à Cloud Build > History (Cloud Build > Historique) et attendez quelques minutes que la nouvelle compilation s'affiche. Vous devrez peut-être actualiser la page. Attendez la fin de la compilation avant de passer à l'étape suivante.
Retournez dans l'interface utilisateur de Spinnaker et cliquez sur Pipelines. Vous pouvez voir que le pipeline commence à déployer l'image. L'affichage du pipeline déclenché automatiquement prend quelques minutes. Vous devrez peut-être actualiser la page.

Tester la tâche terminée

Cliquez sur Check my progress (Vérifier ma progression) pour vérifier la tâche exécutée. Si vous avez réussi à déclencher un pipeline suite à des modifications de code, vous verrez une note d'évaluation s'afficher.

Déclencher un pipeline suite à des modifications de code

Observer les déploiements Canary

Lorsque le déploiement est suspendu, attendant de passer en production, retournez à la page web affichant votre application en cours d'exécution et actualisez l'onglet. 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 cinq actualisations environ.
Une fois le pipeline terminé, votre application ressemble à la capture d'écran suivante. Notez que la couleur est passée au bleu en raison de la modification du code et que le champ Version affiche désormais canary.

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

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

Appuyez sur les touches CTRL+O, ENTRÉE, CTRL+X.

git tag v1.0.2

git push --tags

Une fois la compilation et le pipeline terminés, vérifiez que le rollback a bien été effectué en cliquant sur Infrastructure > Load Balancers (Infrastructure > Équilibreurs de charge). Sous service sample-frontend-production, cliquez sur Default (Par défaut) et copiez l'adresse IP entrante dans un nouvel onglet.

Votre application est à nouveau orange et le numéro de version de production a changé.

Félicitations

L'atelier "Pipelines de livraison continue avec Spinnaker et Kubernetes Engine" est désormais terminé.

Terminer votre quête

Cet atelier d'auto-formation fait partie des quêtes Qwiklabs Google Cloud Solutions I: Scaling Your Infrastructure et DevOps Essentials. Une quête est une série d'ateliers associés qui constituent une formation. Si vous terminez cette quête, vous obtiendrez le badge ci-dessus attestant de votre réussite. Vous pouvez rendre publics les badges que vous recevez et ajouter leur lien dans votre CV en ligne ou sur vos comptes de réseaux sociaux. Inscrivez-vous à cette quête pour obtenir immédiatement les crédits associés à cet atelier si vous l'avez suivi. Découvrez les autres quêtes Qwiklabs disponibles.

Atelier suivant

Continuez sur votre lancée en suivant l'atelier Exécuter des serveurs de jeu dédiés dans Google Kubernetes Engine ou consultez ces suggestions :

Dépannage de la fiabilité du site à l'aide de Stackdriver APM

Étapes suivantes et informations supplémentaires

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 9 mars 2021

Dernier test de l'atelier : 9 mars 2021

Copyright 2020 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.