1. Introduction
Exécuter des sites Web et des applications n'est pas chose facile.
Des problèmes inattendus surviennent, les serveurs plantent, l'augmentation de la demande accroît la quantité de ressources nécessaires, et apporter des modifications en évitant les temps d'arrêt se révèle aussi complexe que stressant.
Imaginez un outil qui pourrait vous aider à accomplir l'ensemble de ces tâches, et même à les automatiser. Grâce à GKE, toutes ces opérations sont non seulement possibles, mais aussi d'une grande simplicité. Dans cet atelier de programmation, vous allez jouer le rôle d'un développeur qui gère un site Web d'e-commerce pour une entreprise fictive, Fancy Store. En raison de problèmes de scaling et d'interruptions, vous êtes chargé de déployer votre application sur GKE.
Les exercices sont organisés selon une approche fréquemment suivie par les développeurs cloud :
- créer un cluster GKE ;
- Créez un conteneur Docker.
- Déployez le conteneur sur GKE.
- Exposez le conteneur via un service.
- Procédez au scaling du conteneur pour en exécuter plusieurs instances répliquées.
- Modifiez le site Web.
- Déployez une nouvelle version sans aucun temps d'arrêt.
Schéma de l'architecture
Points abordés
- Créer un cluster GKE
- Créer une image Docker
- Déployer des images Docker sur Kubernetes
- Procéder au scaling d'une application sur Kubernetes
- Effectuer une mise à jour progressive sur Kubernetes
Prérequis
- Un compte Google disposant d'un accès administrateur pour créer des projets ou un projet avec le rôle de propriétaire du projet
- Connaissance de base de Docker et Kubernetes (si vous n'avez pas de connaissances de base, veuillez consulter Docker et Kubernetes maintenant)
2. Configuration de l'environnement
Configuration de l'environnement au rythme de chacun
Si vous ne possédez pas encore de compte Google, vous devez en créer un. Connectez-vous à la console Google Cloud et créez un projet.
Notez que l'ID du projet est un nom unique pour tous les projets Google Cloud, ce qui implique que le nom ci-dessus n'est plus disponible pour vous… Désolé ! Il sera désigné par le nom PROJECT_ID par la suite.
Vous devez ensuite activer la facturation dans la console Cloud pour pouvoir utiliser les ressources Google Cloud. Les nouveaux utilisateurs de Google Cloud peuvent s'inscrire à un essai sans frais pour bénéficier d'un crédit de 300$. Si vous n'êtes pas un nouvel utilisateur, ne vous inquiétez pas, car l'atelier de programmation ne devrait pas vous coûter plus de quelques euros. Cependant, l'atelier de programmation peut vous coûter plus cher si vous utilisez davantage de ressources ou si vous les laissez s'exécuter (voir la section "Nettoyer" à la fin). Pour en savoir plus, reportez-vous à la page Tarifs.
Cloud Shell
Bien que vous puissiez utiliser Google Cloud et GKE à distance avec votre ordinateur portable, vous allez utiliser Cloud Shell, un environnement de ligne de commande exécuté dans le cloud, pour cet atelier de programmation.
Cette machine virtuelle basée sur Debian contient tous les outils de développement dont vous aurez besoin. Elle intègre un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Cela signifie que tout ce dont vous avez besoin pour cet atelier de programmation est un navigateur (oui, tout fonctionne sur un Chromebook).
- Pour activer Cloud Shell à partir de Cloud Console, cliquez simplement sur Activer Cloud Shell
(l'opération de provisionnement et la connexion à l'environnement ne devraient prendre que quelques minutes).
Une fois connecté à Cloud Shell, vous êtes normalement déjà authentifié et le projet PROJECT_ID est sélectionné :
gcloud auth list
Résultat de la commande
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
gcloud config list project
Résultat de la commande
[core] project = <PROJECT_ID>
Si, pour une raison quelconque, le projet n'est pas défini, exécutez simplement la commande suivante :
gcloud config set project <PROJECT_ID>
Vous recherchez votre PROJECT_ID ? Vérifiez l'ID que vous avez utilisé pendant les étapes de configuration ou recherchez-le dans le tableau de bord Cloud Console :
Par défaut, Cloud Shell définit certaines variables d'environnement qui pourront s'avérer utiles pour exécuter certaines commandes dans le futur.
echo $GOOGLE_CLOUD_PROJECT
Résultat de la commande
<PROJECT_ID>
- Pour finir, définissez la configuration du projet et de la zone par défaut :
gcloud config set compute/zone us-central1-f
Vous pouvez choisir parmi différentes zones. Pour en savoir plus, consultez Régions et zones.
3. Créer un cluster GKE
Maintenant que votre environnement de développement est opérationnel, vous avez besoin d'un cluster GKE pour déployer votre site Web. Avant de créer un cluster, vous devez vous assurer que les API appropriées sont activées. Exécutez la commande suivante pour activer l'API Containers :
gcloud services enable container.googleapis.com
Vous pouvez maintenant créer votre cluster. Suivez les étapes ci-dessous pour créer un cluster nommé fancy-cluster avec 3 nœuds :
gcloud container clusters create fancy-cluster --num-nodes 3
La création du cluster peut prendre plusieurs minutes. Ensuite, exécutez la commande suivante pour afficher les trois instances de VM de nœud de calcul du cluster :
gcloud compute instances list
Résultat :
NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS gke-fancy-cluster-default-pool-ad92506d-1ng3 us-east4-a n1-standard-1 10.150.0.7 XX.XX.XX.XX RUNNING gke-fancy-cluster-default-pool-ad92506d-4fvq us-east4-a n1-standard-1 10.150.0.5 XX.XX.XX.XX RUNNING gke-fancy-cluster-default-pool-ad92506d-4zs3 us-east4-a n1-standard-1 10.150.0.6 XX.XX.XX.XX RUNNING
Vous pouvez également visualiser votre cluster et les informations associées dans la console Cloud. Cliquez sur le bouton de menu en haut à gauche, faites défiler la page jusqu'à Kubernetes Engine, puis cliquez sur "Clusters". Le cluster nommé fancy-cluster doit s'afficher.
Félicitations ! Vous avez créé votre premier cluster !
4. Cloner le dépôt source
Puisqu'il s'agit d'un site Web existant, il vous suffit de cloner la source à partir du dépôt pour pouvoir vous concentrer sur la création d'images Docker et sur leur déploiement sur GKE.
Exécutez les commandes suivantes pour cloner le dépôt source dans votre instance Cloud Shell et accéder au répertoire approprié. Vous allez également installer les dépendances Node.js de manière à pouvoir tester votre application avant de la déployer.
cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices ./setup.sh
Cela clone le dépôt, modifie le répertoire et installe les dépendances nécessaires à l'exécution locale de votre application. L'exécution de ce script peut prendre quelques minutes.
Faites preuve de diligence raisonnable et testez votre application. Exécutez la commande suivante pour démarrer votre serveur Web :
cd ~/monolith-to-microservices/monolith npm start
Résultat :
Monolith listening on port 8080!
Vous pouvez prévisualiser votre application en cliquant sur l'icône d'aperçu sur le Web dans le menu Cloud Shell, puis en sélectionnant "Prévisualiser sur le port 8080".
Vous devez voir s'afficher une nouvelle fenêtre présentant votre site Fancy Store en action.
Vous pouvez fermer cette fenêtre après avoir consulté le site Web. Appuyez sur Control+C (Windows ou Mac) dans la fenêtre de terminal pour arrêter le processus du serveur Web.
5. Créer un conteneur Docker avec Cloud Build
Maintenant que vos fichiers sources sont prêts à l'emploi, le moment est venu de déployer votre application dans un conteneur Docker.
En temps normal, vous devriez adopter une approche en deux étapes consistant à créer un conteneur Docker, puis à le transférer vers un registre afin de stocker l'image pour que GKE puisse l'extraire. Toutefois, vous pouvez vous simplifier la vie en utilisant Cloud Build pour créer le conteneur Docker et pour placer l'image dans Container Registry en une seule opération. (Pour découvrir comment créer et transférer un fichier Docker manuellement, consultez le Guide de démarrage rapide pour Container Registry.)
Cloud Build compresse les fichiers du répertoire et les déplace vers un bucket Cloud Storage. Le processus de compilation récupère ensuite les fichiers du bucket et utilise le Dockerfile pour exécuter le processus de compilation Docker. Étant donné que vous avez spécifié l'option --tag avec l'hôte en tant que gcr.io pour l'image Docker, l'image Docker résultante est transférée vers Container Registry.
Pour commencer, vous devez activer l'API Cloud Build en exécutant la commande suivante :
gcloud services enable cloudbuild.googleapis.com
Une fois l'API activée, exécutez la commande suivante dans Cloud Shell pour lancer le processus de compilation :
cd ~/monolith-to-microservices/monolith
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 .
Ce processus prend quelques minutes, mais une fois terminé, vous pouvez voir le résultat suivant dans le terminal :
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ID CREATE_TIME DURATION SOURCE IMAGES STATUS 1ae295d9-63cb-482c-959b-bc52e9644d53 2019-08-29T01:56:35+00:00 33S gs://<PROJECT_ID>_cloudbuild/source/1567043793.94-abfd382011724422bf49af1558b894aa.tgz gcr.io/<PROJECT_ID>/monolith:1.0.0 SUCCESS
Pour consulter votre historique de compilation ou suivre le processus en temps réel, vous pouvez accéder à la console Cloud. Cliquez sur le bouton de menu en haut à gauche, faites défiler la page jusqu'à "CI/CD", puis cliquez sur "Cloud Build" et enfin sur "Historique". Vous pouvez y voir la liste de vos compilations précédentes, mais seule celle que vous venez de créer devrait apparaître.
Si vous cliquez sur l'ID de compilation, vous pouvez consulter tous les détails de cette compilation, y compris la sortie du journal.
Sur la page d'informations sur le build, vous pouvez consulter l'image de conteneur créée en cliquant sur le nom de l'image dans la section des informations sur le build.
6. Déployer le conteneur sur GKE
Maintenant que vous avez conteneurisé votre site Web et transféré le conteneur vers Container Registry, vous pouvez le déployer sur Kubernetes.
Pour déployer et gérer des applications sur un cluster GKE, vous devez communiquer avec le système de gestion de clusters Kubernetes. Pour ce faire, vous utiliserez généralement l'outil de ligne de commande kubectl.
Kubernetes représente les applications sous forme de pods, qui sont des unités représentant un conteneur (ou un groupe de conteneurs fortement couplés). Le pod est la plus petite unité déployable dans Kubernetes. Ici, chaque pod ne contient que votre conteneur monolithique.
Pour déployer votre application, vous devez créer un déploiement. Un déploiement gère plusieurs copies de votre application, appelées répliques, et planifie leur exécution sur les nœuds individuels de votre cluster. Dans ce cas, le déploiement n'exécute qu'un seul pod de l'application. Les déploiements garantissent ce résultat en créant un ReplicaSet. Le rôle du ReplicaSet est de garantir l'exécution systématique du nombre d'instances répliquées spécifié.
La commande kubectl create deployment demande à Kubernetes de créer sur votre cluster un déploiement nommé monolith avec 1 instance répliquée.
Exécutez la commande suivante pour déployer votre application :
kubectl create deployment monolith --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0
Vérifier le déploiement
Pour vérifier que le déploiement a bien été créé, exécutez la commande suivante (l'état du pod peut prendre quelques instants pour passer à "Running") :
kubectl get all
Résultat :
NAME READY STATUS RESTARTS AGE pod/monolith-7d8bc7bf68-htm7z 1/1 Running 0 6m21s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/kubernetes ClusterIP 10.27.240.1 <none> 443/TCP 24h NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE deployment.apps/monolith 1 1 1 1 20m NAME DESIRED CURRENT READY AGE replicaset.apps/monolith-7d8bc7bf68 1 1 1 20m
Ce résultat vous indique différentes choses. Cette sortie vous présente le déploiement qui est actuellement exécuté, le ReplicaSet avec un nombre de pods souhaité égal à 1, et le pod qui est en cours d'exécution. Il semble que vous ayez tout créé !
Pour afficher vos ressources individuellement, vous pouvez exécuter les commandes suivantes :
# Show pods kubectl get pods # Show deployments kubectl get deployments # Show replica sets kubectl get rs #You can also combine them kubectl get pods,deployments
Pour voir clairement les avantages de Kubernetes, vous pouvez simuler un plantage du serveur, supprimer le pod et observer ce qui se passe.
Copiez le nom de votre pod à partir de la commande précédente, puis exécutez la commande suivante pour le supprimer :
kubectl delete pod/<POD_NAME>
Si vous êtes suffisamment rapide, vous pouvez réexécuter la commande précédente pour tout afficher. Vous devriez alors voir deux pods, l'un en cours d'arrêt et l'autre en cours de création ou d'exécution :
kubectl get all
Résultat :
NAME READY STATUS RESTARTS AGE pod/monolith-7d8bc7bf68-2bxts 1/1 Running 0 4s pod/monolith-7d8bc7bf68-htm7z 1/1 Terminating 0 9m35s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/kubernetes ClusterIP 10.27.240.1 <none> 443/TCP 24h NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE deployment.apps/monolith 1 1 1 1 24m NAME DESIRED CURRENT READY AGE replicaset.apps/monolith-7d8bc7bf68 1 1 1 24m
Pourquoi ? Le ReplicaSet a vu que le pod était en cours d'arrêt et a donc déclenché un nouveau pod pour préserver le nombre d'instances répliquées souhaité. Par la suite, vous découvrirez comment effectuer un scaling pour garantir l'exécution systématique de plusieurs instances. De cette manière, les utilisateurs ne constateront aucun temps d'arrêt en cas de défaillance de l'une des instances.
7. Exposer le déploiement GKE
Vous avez déployé votre application sur GKE, mais vous ne pouvez pas y accéder en dehors du cluster. Par défaut, les conteneurs que vous exécutez sur GKE ne sont pas accessibles depuis Internet, car ils ne possèdent pas d'adresses IP externes. Vous devez donc exposer explicitement votre application au trafic Internet via une ressource Service. Un service offre une compatibilité réseau et IP avec les pods de votre application. GKE crée une adresse IP externe et un équilibreur de charge (susceptible d'être facturé) pour votre application.
Exécutez la commande suivante pour exposer votre site Web à Internet :
kubectl expose deployment monolith --type=LoadBalancer --port 80 --target-port 8080
Résultat :
service/monolith exposed
Accéder au service
GKE attribue l'adresse IP externe à la ressource de service, et non à la ressource de déploiement. Si vous souhaitez connaître l'adresse IP externe provisionnée par GKE pour votre application, vous pouvez inspecter le service à l'aide de la commande kubectl get service :
kubectl get service
Résultat :
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE monolith 10.3.251.122 203.0.113.0 80:30877/TCP 3d
Une fois que vous avez déterminé l'adresse IP externe de votre application, copiez-la. Pointez le navigateur sur cette URL (telle que http://203.0.113.0) pour vérifier si votre application est accessible.
Le site Web que vous avez testé précédemment doit alors s'afficher. Félicitations ! Votre site Web s'exécute désormais entièrement sur Kubernetes.
8. Effectuer le scaling du déploiement GKE
Maintenant que vous disposez d'une instance en cours d'exécution de votre application dans GKE et que vous l'avez exposée à Internet, votre site Web est devenu extrêmement populaire. Vous devez donc procéder au scaling de votre application de manière à en exécuter plusieurs instances pour lui permettre de gérer le trafic. Apprenez à faire évoluer votre application jusqu'à trois instances répliquées.
Exécutez la commande suivante pour effectuer le scaling à la hausse de votre déploiement pour qu'il passe à trois instances répliquées :
kubectl scale deployment monolith --replicas=3
Résultat :
deployment.apps/monolith scaled
Vérifier le déploiement à l'échelle
Pour vérifier que le scaling du déploiement a bien été effectué, exécutez la commande suivante :
kubectl get all
Résultat :
NAME READY STATUS RESTARTS AGE pod/monolith-7d8bc7bf68-2bxts 1/1 Running 0 36m pod/monolith-7d8bc7bf68-7ds7q 1/1 Running 0 45s pod/monolith-7d8bc7bf68-c5kxk 1/1 Running 0 45s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/kubernetes ClusterIP 10.27.240.1 <none> 443/TCP 25h service/monolith LoadBalancer 10.27.253.64 XX.XX.XX.XX 80:32050/TCP 6m7s NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE deployment.apps/monolith 3 3 3 3 61m NAME DESIRED CURRENT READY AGE replicaset.apps/monolith-7d8bc7bf68 3 3 3 61m
Trois instances de votre pod doivent désormais être en cours d'exécution. Notez également que le nombre d'instances souhaité pour votre déploiement et votre ReplicaSet est maintenant égal à trois.
9. Apporter des modifications au site Web
Votre équipe marketing vous a demandé de modifier la page d'accueil de votre site Web. Elle estime en effet que cette page doit fournir plus d'informations sur votre entreprise et sur les produits qu'elle commercialise. Dans cette section, vous allez ajouter du texte à la page d'accueil pour répondre aux attentes de l'équipe marketing. L'un de nos développeurs a déjà spécifié les modifications souhaitées dans le fichier index.js.new. Vous pouvez copier le fichier dans index.js pour répercuter vos modifications. Suivez les instructions ci-dessous pour apporter les changements appropriés.
Exécutez les commandes suivantes pour copier le fichier mis à jour sous le nom de fichier correct, puis affichez le contenu de ce fichier pour vérifier les modifications :
cd ~/monolith-to-microservices/react-app/src/pages/Home mv index.js.new index.js cat ~/monolith-to-microservices/react-app/src/pages/Home/index.js
Le code obtenu doit se présenter comme suit :
/*
Copyright 2019 Google LLC
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import React from "react";
import { makeStyles } from "@material-ui/core/styles";
import Paper from "@material-ui/core/Paper";
import Typography from "@material-ui/core/Typography";
const useStyles = makeStyles(theme => ({
root: {
flexGrow: 1
},
paper: {
width: "800px",
margin: "0 auto",
padding: theme.spacing(3, 2)
}
}));
export default function Home() {
const classes = useStyles();
return (
<div className={classes.root}>
<Paper className={classes.paper}>
<Typography variant="h5">
Fancy Fashion & Style Online
</Typography>
<br />
<Typography variant="body1">
Tired of mainstream fashion ideas, popular trends and societal norms?
This line of lifestyle products will help you catch up with the Fancy trend and express your personal style.
Start shopping Fancy items now!
</Typography>
</Paper>
</div>
);
}
Vous avez mis à jour les composants React, mais vous devez compiler l'application React pour générer les fichiers statiques. Exécutez la commande suivante pour compiler l'application React et la copier dans le répertoire public "monolith" :
cd ~/monolith-to-microservices/react-app npm run build:monolith
Maintenant que votre code a été mis à jour, vous devez recompiler votre conteneur Docker et le publier dans Container Registry. Vous pouvez utiliser la même commande que précédemment, mais cette fois en mettant à jour l'étiquette de la version.
Exécutez la commande suivante pour déclencher une nouvelle compilation Cloud Build avec la version d'image mise à jour de 2.0.0 :
cd ~/monolith-to-microservices/monolith
#Feel free to test your application
npm start
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .
Appuyez sur Control+C (Windows ou Mac) dans la fenêtre de terminal pour arrêter le processus du serveur Web.
Dans la section suivante, vous allez utiliser cette image pour mettre à jour votre application sans aucun temps d'arrêt.
10. Mettre à jour le site Web sans aucun temps d'arrêt
Les modifications ont été effectuées, puis validées par l'équipe marketing. Le moment est venu de mettre à jour le site Web en conséquence sans interruption pour les utilisateurs. Suivez les instructions ci-dessous pour mettre à jour votre site Web.
Les mises à jour progressives de GKE garantissent que votre application reste active et disponible, même lorsque le système remplace les instances de l'ancienne image de conteneur par la nouvelle image sur toutes les instances répliquées en cours d'exécution.
À partir de la ligne de commande, vous pouvez indiquer à Kubernetes que vous voulez remplacer l'image de votre déploiement par une nouvelle version avec la commande suivante :
kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0
Résultat :
deployment.apps/monolith image updated
Vérifier le déploiement
Vous pouvez vérifier que votre déploiement a été mis à jour en exécutant la commande suivante :
kubectl get pods
Résultat :
NAME READY STATUS RESTARTS AGE monolith-584fbc994b-4hj68 1/1 Terminating 0 60m monolith-584fbc994b-fpwdw 1/1 Running 0 60m monolith-584fbc994b-xsk8s 1/1 Terminating 0 60m monolith-75f4cf58d5-24cq8 1/1 Running 0 3s monolith-75f4cf58d5-rfj8r 1/1 Running 0 5s monolith-75f4cf58d5-xm44v 0/1 ContainerCreating 0 1s
Vous pouvez constater que trois pods sont en cours de création et que vos anciens pods sont en train d'être arrêtés. La durée d'exécution vous permet de différencier les nouveaux pods des anciens. À terme, vous ne verrez plus que trois pods, qui correspondent aux trois pods que vous avez mis à jour.
Pour vérifier vos modifications, accédez à nouveau à l'adresse IP externe de l'équilibreur de charge et notez que votre application a été mise à jour.
Si vous avez oublié l'adresse IP, exécutez la commande suivante pour lister les services et l'afficher :
kubectl get svc
Votre site Web doit afficher le texte que vous avez ajouté au composant de la page d'accueil.
11. Effectuer un nettoyage
Supprimer le dépôt Git
cd ~ rm -rf monolith-to-microservices
Supprimer des images Container Registry
REMARQUE : Si vous avez créé d'autres versions, vous pouvez utiliser la même syntaxe pour les supprimer également. Cet atelier de programmation suppose que vous n'avez que deux balises.
# Delete the container image for version 1.0.0 of our monolith
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --quiet
# Delete the container image for version 2.0.0 of our monolith
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 --quiet
Supprimer les artefacts Cloud Build de Cloud Storage
REMARQUE : Si vous avez utilisé Cloud Build pour des artefacts autres que ceux de cet atelier de programmation, vous devrez supprimer manuellement votre source du bucket Cloud Storage gs://<PROJECT_ID>_cloudbuild/source.
# The following command will take all source archives from all builds and delete them from cloud storage
# Run this command to print all sources:
# gcloud builds list | awk 'NR > 1 {print $4}'
gcloud builds list | awk 'NR > 1 {print $4}' | while read line; do gsutil rm $line; done
Supprimer le service GKE
kubectl delete service monolith kubectl delete deployment monolith
Supprimer le cluster GKE
gcloud container clusters delete fancy-cluster
REMARQUE : L'exécution de cette commande peut prendre un certain temps.
12. Félicitations !
Vous avez déployé, mis à l'échelle et mis à jour votre site Web sur GKE. Vous savez maintenant utiliser Docker et Kubernetes.