Cette page a été traduite par l'API Cloud Translation.

Hébergez et faites évoluer une application Web dans Google Cloud avec Compute Engine

1. Introduction

Il existe de nombreuses façons de déployer des sites Web dans Google Cloud, chacune d'elles offrant des fonctionnalités, des capacités et des niveaux de contrôle différents. Compute Engine offre un niveau de contrôle approfondi sur l'infrastructure utilisée pour exécuter un site Web, mais nécessite également une gestion opérationnelle un peu plus importante que des solutions telles que Google Kubernetes Engine, App Engine, etc. Avec Compute Engine, vous pouvez contrôler précisément les aspects de l'infrastructure, y compris les machines virtuelles, l'équilibreur de charge, etc. Aujourd'hui, vous allez déployer un exemple d'application (le site Web d'e-commerce de Fancy Store) pour montrer comment un site Web peut être déployé et évoluer facilement avec Compute Engine.

Points abordés

Créer des instances Compute Engine
Créer des modèles d'instance à partir d'instances sources
Créer des groupes d'instances gérés
Configurer les vérifications de l'état et l'autoréparation
Créer un équilibrage de charge HTTP(S)
Créer des vérifications d'état pour les équilibreurs de charge
Utiliser un réseau de diffusion de contenu pour la mise en cache

À la fin de l'atelier de programmation, vous disposerez d'instances dans des groupes d'instances gérés pour assurer l'autoréparation, l'équilibrage de charge, l'autoscaling et les mises à jour progressives de votre site Web.

Prérequis

Pour obtenir une présentation générale des concepts que nous allons utiliser dans cet atelier, consultez les ressources ci-dessous:
Bienvenue dans le cours Google Cloud Platform : les principes de base de GCP
Premiers pas avec Google Cloud Compute Engine
Premiers pas avec Google Cloud Storage
Premiers pas: Cloud Shell

2. Cofiguration de l'environnement

Configuration de l'environnement au rythme de chacun

Connectez-vous à la console Cloud, puis créez un projet ou réutilisez un projet existant. (Si vous ne possédez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.)

Mémorisez l'ID du projet. Il s'agit d'un nom unique permettant de différencier chaque projet Google Cloud (le nom ci-dessus est déjà pris ; vous devez en trouver un autre). Il sera désigné par le nom PROJECT_ID tout au long de cet atelier de programmation.

Vous devez ensuite activer la facturation dans Cloud Console pour pouvoir utiliser les ressources Google Cloud.

L'exécution de cet atelier de programmation est très peu coûteuse, voire gratuite. Veillez à suivre les instructions de la section "Nettoyer" qui indique comment désactiver les ressources afin d'éviter les frais une fois ce tutoriel terminé. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300$.

Activer l'API Compute Engine

Vous devez ensuite activer l'API Compute Engine. Pour activer une API, vous devez en accepter les conditions d'utilisation et assumer la responsabilité de la facturation.

Dans Cloud Shell, exécutez la commande suivante pour activer l'API Compute Engine:

gcloud services enable compute.googleapis.com

Cloud Shell

Google Cloud peut être utilisé à distance depuis votre ordinateur portable. Toutefois, dans cet atelier de programmation, vous allez utiliser Cloud Shell, un environnement de ligne de commande exécuté dans le cloud.

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

Capture d'écran du 2017-06-14 à 10.13.43 PM.png

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 la page Régions et zones.

Créer un bucket Cloud Storage

Nous allons utiliser un bucket Cloud Storage pour héberger notre code compilé, ainsi que nos scripts de démarrage. Dans Cloud Shell, exécutez la commande suivante pour créer un bucket Cloud Storage:

gsutil mb gs://fancy-store-$DEVSHELL_PROJECT_ID

3. Cloner le dépôt source

Vous allez utiliser le site Web d'e-commerce existant de Fancy Store, basé sur le dépôt monolith-to-microservices, comme base pour votre site Web. Vous allez cloner le code source à partir de votre dépôt afin de pouvoir vous concentrer sur les différents aspects du déploiement sur Compute Engine. Par la suite, vous effectuerez une petite mise à jour du code pour démontrer la simplicité des mises à jour sur Compute Engine.

Vous pouvez cloner automatiquement le dépôt de code dans le projet, et ouvrir Cloud Shell et l'éditeur de code intégré en cliquant sur le lien suivant: Ouvrir dans Cloud Shell.

Vous pouvez également cloner manuellement le dépôt à l'aide des commandes ci-dessous dans Cloud Shell:

cd ~
git clone https://github.com/googlecodelabs/monolith-to-microservices.git
cd ~/monolith-to-microservices

Lorsque l'invite de commande Cloud Shell s'affiche, exécutez la compilation initiale du code pour permettre à l'application de s'exécuter localement. L'exécution du script peut prendre quelques minutes.

./setup.sh

Faites preuve de diligence raisonnable et testez votre application. Exécutez la commande suivante pour démarrer votre serveur Web:

cd microservices
npm start

Sortie :

Products microservice listening on port 8082!
Frontend microservice listening on port 8080!
Orders microservice listening on port 8081!

Prévisualisez votre application en cliquant sur l'icône d'aperçu sur le Web, puis en sélectionnant "Prévisualiser sur le port 8080".

Une nouvelle fenêtre contenant l'interface de Fancy Store en action doit s'afficher.

Vous pouvez fermer cette fenêtre après avoir consulté le site Web. Pour arrêter le processus du serveur Web, appuyez sur Control+C (Command+C sur Macintosh) dans la fenêtre de terminal.

4. Créer des instances Compute Engine

Maintenant que vous disposez d'un environnement de développement opérationnel, vous pouvez déployer des instances Compute Engine. Au cours des étapes suivantes, vous allez:

Créez un script de démarrage pour configurer les instances.
Clonez le code source et importez-le dans Cloud Storage.
Déployez une instance Compute Engine pour héberger les microservices backend.
Reconfigurez le code de l'interface (frontend) pour qu'il utilise l'instance des microservices backend.
Déployez une instance Compute Engine pour héberger le microservice frontend.
Configurez le réseau pour autoriser la communication.

Créer un script de démarrage

Nous allons utiliser un script de démarrage pour indiquer à l'instance les opérations à effectuer à chaque démarrage. De cette manière, les instances sont automatiquement configurées.

Cliquez sur l'icône en forme de crayon dans le ruban Cloud Shell pour ouvrir l'éditeur de code.

Accédez au dossier "monolith-to-microservices". Cliquez sur Fichier > New File (Nouveau fichier) et créer un fichier nommé startup-script.sh.

Dans le nouveau fichier, collez le code suivant, dont vous modifierez certains par la suite:

#!/bin/bash

# Install logging monitor. The monitor will automatically pick up logs sent to
# syslog.
curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash
service google-fluentd restart &

# Install dependencies from apt
apt-get update
apt-get install -yq ca-certificates git build-essential supervisor psmisc

# Install nodejs
mkdir /opt/nodejs
curl https://nodejs.org/dist/v8.12.0/node-v8.12.0-linux-x64.tar.gz | tar xvzf - -C /opt/nodejs --strip-components=1
ln -s /opt/nodejs/bin/node /usr/bin/node
ln -s /opt/nodejs/bin/npm /usr/bin/npm

# Get the application source code from the Google Cloud Storage bucket.
mkdir /fancy-store
gsutil -m cp -r gs://fancy-store-[DEVSHELL_PROJECT_ID]/monolith-to-microservices/microservices/* /fancy-store/

# Install app dependencies.
cd /fancy-store/
npm install

# Create a nodeapp user. The application will run as this user.
useradd -m -d /home/nodeapp nodeapp
chown -R nodeapp:nodeapp /opt/app

# Configure supervisor to run the node app.
cat >/etc/supervisor/conf.d/node-app.conf << EOF
[program:nodeapp]
directory=/fancy-store
command=npm start
autostart=true
autorestart=true
user=nodeapp
environment=HOME="/home/nodeapp",USER="nodeapp",NODE_ENV="production"
stdout_logfile=syslog
stderr_logfile=syslog
EOF

supervisorctl reread
supervisorctl update

Maintenant, dans l'éditeur de code, recherchez le texte [DEVSHELL_PROJECT_ID] et remplacez-le par le résultat de la commande suivante:

echo $DEVSHELL_PROJECT_ID

Exemple de résultat :

my-gce-codelab-253520

La ligne de code dans startup-script.sh doit maintenant être semblable à celle-ci:

gs://fancy-store-my-gce-codelab-253520/monolith-to-microservices/microservices/* /fancy-store/

Le script de démarrage effectue les tâches suivantes :

Installation de l'agent Logging, qui collecte automatiquement les journaux de syslog
Installation de Node.js et de Supervisor, qui exécute l'application en tant que daemon
Cloner le code source de l'application à partir du bucket Cloud Storage et installation des dépendances
La configuration de Supervisor, qui exécute l'application, garantit que l'application est redémarrée si elle se ferme de manière inattendue, ou si elle est arrêtée par un administrateur ou un processus, et envoie les fichiers stdout et stderr de l'application à syslog pour que l'agent Logging puisse les collecter.

Copiez maintenant le fichier startup-script.sh créé dans le bucket Cloud Storage créé précédemment:

gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-$DEVSHELL_PROJECT_ID

Il est désormais accessible à l'adresse https://storage.googleapis.com/[BUCKET_NAME]/startup-script.sh. [BUCKET_NAME] représente le nom du bucket Cloud Storage. Par défaut, seuls les utilisateurs autorisés et les comptes de service pourront la voir. Elle sera donc inaccessible depuis un navigateur Web. Les instances Compute Engine y auront automatiquement accès via leurs comptes de service.

Copier le code dans le bucket Cloud Storage

Lorsque les instances démarrent, elles récupèrent le code du bucket Cloud Storage afin que vous puissiez stocker certaines variables de configuration dans le fichier du code.

Copiez le code cloné dans le bucket Cloud Storage:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Déployer l'instance backend

La première instance que vous allez déployer sera l'instance backend, qui hébergera les microservices "Orders" et "Products".

Exécutez la commande suivante dans Cloud Shell pour créer une instance f1-micro configurée pour utiliser votre script de démarrage créé précédemment et taguée en tant qu'instance backend afin que vous puissiez lui appliquer ultérieurement des règles de pare-feu spécifiques:

gcloud compute instances create backend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=backend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

Configurer la connexion au backend

Avant de déployer l'interface de l'application, vous devez mettre à jour la configuration pour qu'elle pointe vers le backend que vous avez déployé.

Récupérez l'adresse IP externe du backend, que vous pouvez afficher à l'aide de la commande suivante dans l'onglet EXTERNAL_IP de l'instance backend:

gcloud compute instances list

Exemple de résultat :

NAME     ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP   STATUS
backend  us-central1-a  f1-micro                   10.128.0.2   34.68.223.88  RUNNING

Dans l'éditeur de code Cloud Shell, accédez au dossier monolith-to-microservices > react-app. Dans le menu de l'éditeur de code, sélectionnez Affichage > Activez l'option "Fichiers cachés" pour voir le fichier .env.

Modifiez le fichier .env pour qu'il pointe vers l'adresse IP externe du backend. L'[ADRESSE_DU_BACKEND] ci-dessous représente l'adresse IP externe de l'instance backend déterminée au moyen de la commande précédente exécutée dans l'outil gcloud.

REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders
REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products

Enregistrez le fichier.

Utilisez la commande suivante pour recompiler l'application réactive, ce qui mettra à jour le code de l'interface:

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Copiez le code de l'application dans le bucket Cloud Storage:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Déployer l'instance frontend

Maintenant que le code est configuré, vous pouvez déployer l'instance frontend. Exécutez la commande suivante pour déployer l'instance frontend à l'aide d'une commande semblable à celle utilisée précédemment, mais avec le tag "frontend" : à des fins de pare-feu.

gcloud compute instances create frontend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=frontend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

Configurer le réseau

Créez des règles de pare-feu afin d'autoriser l'accès au port 8080 pour l'interface, et aux ports 8081 et 8082 pour le backend. Les commandes de pare-feu utilisent les tags attribués lors de la création des instances pour l'application.

gcloud compute firewall-rules create fw-fe \
    --allow tcp:8080 \
    --target-tags=frontend

gcloud compute firewall-rules create fw-be \
    --allow tcp:8081-8082 \
    --target-tags=backend

Le site Web doit maintenant être fonctionnel. Déterminez l'adresse IP externe de l'interface. L'adresse peut être déterminée en recherchant l'adresse IP externe (EXTERNAL_IP) de l'instance frontend:

gcloud compute instances list

Exemple de résultat :

NAME      ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP      STATUS
backend   us-central1-a  f1-micro                   10.128.0.2   104.198.235.171  RUNNING
frontend  us-central1-a  f1-micro                   10.128.0.3   34.69.141.9      RUNNING

Le démarrage et la configuration de l'instance peuvent prendre quelques minutes. Exécutez la commande suivante pour surveiller l'état de préparation de l'application:

watch -n 5 curl http://[EXTERNAL_IP]:8080

Une fois que vous obtenez un résultat semblable à celui-ci, le site Web doit être prêt. Appuyez sur Control+C (Command+C sur Macintosh) dans l'invite de commande pour annuler la commande de la montre.

Ouvrez l'adresse http://[ADRESSE_DU_FRONTEND]:8080 dans un nouvel onglet de navigateur Web pour accéder au site Web, où [ADRESSE_DU_FRONTEND] correspond à l'ADRESSE IP EXTERNE indiquée ci-dessus.

Essayez d'accéder aux pages "Products" et "Orders", qui devraient également fonctionner.

5. Créer des groupes d'instances gérés

Pour permettre le scaling de votre application, vous allez créer des groupes d'instances gérés qui utiliseront les instances frontend et backend comme modèles d'instance.

Un groupe d'instances géré contient des instances identiques que vous pouvez gérer comme une seule entité dans une même zone. Les groupes d'instances gérés préservent la haute disponibilité de vos applications en s'assurant de manière proactive que vos instances restent disponibles, c'est-à-dire à l'état RUNNING (En cours d'exécution). Vous utiliserez des groupes d'instances gérés pour vos instances frontend et backend afin d'assurer l'autoréparation, l'équilibrage de charge, l'autoscaling et les mises à jour progressives.

Créer un modèle d'instance à partir d'une instance source

Avant de pouvoir créer un groupe d'instances géré, vous devez créer un modèle d'instance qui servira de base au groupe. Les modèles d'instances vous permettent de définir le type de machine, l'image de disque de démarrage ou de conteneur, le réseau, ainsi que d'autres propriétés d'instance à utiliser lorsque vous créez des instances de machine virtuelle (VM). Vous pouvez utiliser des modèles d'instance aussi bien pour créer des instances dans un groupe d'instances géré que pour créer des instances individuelles.

Pour créer le modèle d'instance, utilisez les instances existantes que vous avez créées.

Vous devez d'abord arrêter les deux instances.

gcloud compute instances stop frontend

gcloud compute instances stop backend

À présent, créez le modèle d'instance à partir des instances sources.

gcloud compute instance-templates create fancy-fe \
    --source-instance=frontend

gcloud compute instance-templates create fancy-be \
    --source-instance=backend

Vérifiez que les modèles d'instance ont bien été créés:

gcloud compute instance-templates list

Exemple de résultat :

NAME      MACHINE_TYPE  PREEMPTIBLE  CREATION_TIMESTAMP
fancy-be  f1-micro                   2019-09-12T07:52:57.544-07:00
fancy-fe  f1-micro                   2019-09-12T07:52:48.238-07:00

Créer un groupe d'instances géré

Vous allez créer deux groupes d'instances gérés, l'un pour l'interface et l'autre pour le backend. Ces groupes d'instances gérés utiliseront les modèles d'instance créés précédemment et seront configurés pour démarrer deux instances, chacune dans chaque groupe. Les instances seront automatiquement nommées en fonction du nom de l'instance "base-instance-name" spécifiée avec des caractères aléatoires ajoutés.

gcloud compute instance-groups managed create fancy-fe-mig \
    --base-instance-name fancy-fe \
    --size 2 \
    --template fancy-fe

gcloud compute instance-groups managed create fancy-be-mig \
    --base-instance-name fancy-be \
    --size 2 \
    --template fancy-be

Pour votre application, le microservice frontend s'exécute sur le port 8080, tandis que les microservices backend s'exécutent sur le port 8081 pour les commandes et sur le port 8082 pour les produits. Étant donné qu'il s'agit de ports non standards, vous allez spécifier des ports nommés pour les identifier. Les ports nommés sont des métadonnées de paire clé-valeur qui représentent le nom du service et le port sur lequel le service s'exécute. Les ports nommés peuvent être attribués à un groupe d'instances. Dans ce cas, le service est disponible sur toutes les instances du groupe. Ces informations sont utilisées par l'équilibreur de charge, que vous configurerez ultérieurement.

gcloud compute instance-groups set-named-ports fancy-fe-mig \ 
    --named-ports frontend:8080

gcloud compute instance-groups set-named-ports fancy-be-mig \
    --named-ports orders:8081,products:8082

Configurer l'autoréparation

Pour améliorer la disponibilité de l'application elle-même et vérifier qu'elle répond, vous pouvez configurer une règle d'autoréparation pour les groupes d'instances gérés.

Une règle d'autoréparation repose sur une vérification de l'état basée sur l'application pour s'assurer qu'une application répond comme prévu. Vérifier qu'une application répond est une méthode plus précise que de simplement s'assurer qu'une instance se trouve à l'état RUNNING (En cours d'exécution), qui est le comportement par défaut.

Créez une vérification de l'état qui répare l'instance si elle apparaît trois fois de suite comme non opérationnelle pour l'interface et le backend:

gcloud compute health-checks create http fancy-fe-hc \
    --port 8080 \
    --check-interval 30s \
    --healthy-threshold 1 \
    --timeout 10s \
    --unhealthy-threshold 3

gcloud compute health-checks create http fancy-be-hc \
    --port 8081 \
    --request-path=/api/orders \
    --check-interval 30s \
    --healthy-threshold 1 \
    --timeout 10s \
    --unhealthy-threshold 3

Créez une règle de pare-feu pour autoriser les vérifications de l'état à se connecter aux microservices sur les ports 8080 et 8081:

gcloud compute firewall-rules create allow-health-check \
    --allow tcp:8080-8081 \
    --source-ranges 130.211.0.0/22,35.191.0.0/16 \
    --network default

Appliquez les vérifications d'état à leurs services respectifs :

gcloud compute instance-groups managed update fancy-fe-mig \
    --health-check fancy-fe-hc \
    --initial-delay 300

gcloud compute instance-groups managed update fancy-be-mig \
    --health-check fancy-be-hc \
    --initial-delay 300

Poursuivez l'atelier de programmation pour laisser le temps à l'autoréparation de surveiller les instances du groupe. Par la suite, vous simulerez une défaillance pour tester l'autoréparation.

6. Créer un équilibreur de charge

Pour compléter nos groupes d'instances gérés, vous utiliserez l'équilibrage de charge HTTP(S) pour acheminer le trafic vers les microservices frontend et backend, et vous utiliserez des mappages pour envoyer le trafic aux services de backend appropriés en fonction des règles de chemin d'accès. Cela expose une seule adresse IP à équilibrage de charge pour tous les services.

Pour en savoir plus sur les options d'équilibrage de charge disponibles dans Google Cloud, consultez la page Présentation de l'équilibrage de charge.

Créer un équilibrage de charge HTTP(S)

Google Cloud propose de nombreux types d'équilibrage de charge différents, mais vous utiliserez l'équilibrage de charge HTTP(S) pour votre trafic. L'équilibrage de charge HTTP(S) est structuré comme suit:

Une règle de transfert dirige les requêtes entrantes vers un proxy HTTP cible.
Le proxy HTTP cible analyse chaque requête par rapport à un mappage d'URL afin de déterminer le service de backend approprié pour la requête.
Le service de backend dirige chaque requête vers un backend adapté en fonction de la capacité de diffusion, de la zone et de l'état des instances des backends qui lui sont associés. L'état de chaque instance backend est contrôlé à l'aide d'une vérification d'état HTTP. Si le service de backend est configuré pour utiliser une vérification d'état HTTPS ou HTTP/2, la requête est chiffrée pour être acheminée vers l'instance backend.
Les sessions entre l'équilibreur de charge et l'instance peuvent utiliser le protocole HTTP, HTTPS ou HTTP/2. Si vous utilisez HTTPS ou HTTP/2, chaque instance des services de backend doit disposer d'un certificat SSL.

Créez des vérifications d'état qui serviront à déterminer les instances capables de diffuser le trafic pour chaque service.

gcloud compute http-health-checks create fancy-fe-frontend-hc \
  --request-path / \
  --port 8080

gcloud compute http-health-checks create fancy-be-orders-hc \
  --request-path /api/orders \
  --port 8081

gcloud compute http-health-checks create fancy-be-products-hc \
  --request-path /api/products \
  --port 8082

Créez les services de backend qui constituent la cible du trafic à équilibrage de charge. Les services de backend utiliseront les vérifications d'état et les ports nommés que vous avez créés.

gcloud compute backend-services create fancy-fe-frontend \
  --http-health-checks fancy-fe-frontend-hc \
  --port-name frontend \
  --global

gcloud compute backend-services create fancy-be-orders \
  --http-health-checks fancy-be-orders-hc \
  --port-name orders \
  --global

gcloud compute backend-services create fancy-be-products \
  --http-health-checks fancy-be-products-hc \
  --port-name products \
  --global

Ajoutez les services de backend.

gcloud compute backend-services add-backend fancy-fe-frontend \
  --instance-group fancy-fe-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-orders \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-products \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

Créez un mappage d'URL. Le mappage d'URL définit quelles URL sont dirigées vers des services de backend spécifiques.

gcloud compute url-maps create fancy-map \
  --default-service fancy-fe-frontend

Créez un outil de mise en correspondance des chemins d'accès pour permettre aux chemins d'accès /api/orders et /api/products d'être acheminés vers leurs services respectifs.

gcloud compute url-maps add-path-matcher fancy-map \
   --default-service fancy-fe-frontend \
   --path-matcher-name orders \
   --path-rules "/api/orders=fancy-be-orders,/api/products=fancy-be-products"

Créez le proxy lié au mappage d'URL créé.

gcloud compute target-http-proxies create fancy-proxy \
  --url-map fancy-map

Créez une règle de transfert globale qui associe une adresse IP publique et un port au proxy.

gcloud compute forwarding-rules create fancy-http-rule \
  --global \
  --target-http-proxy fancy-proxy \
  --ports 80

Mettre à jour la configuration

Maintenant que vous disposez d'une nouvelle adresse IP statique, vous devez mettre à jour le code du frontend pour qu'il pointe vers la nouvelle adresse plutôt que vers l'adresse éphémère utilisée précédemment qui pointait vers l'instance backend.

Dans Cloud Shell, accédez au dossier "response-app", qui héberge le fichier .env contenant la configuration.

cd ~/monolith-to-microservices/react-app/

Recherchez l'adresse IP de l'équilibreur de charge:

gcloud compute forwarding-rules list --global

Exemple de résultat :

NAME                    REGION  IP_ADDRESS     IP_PROTOCOL  TARGET
fancy-http-rule          34.102.237.51  TCP          fancy-proxy

Modifiez le fichier .env dans l'éditeur de texte de votre choix (tel que GNU nano) pour qu'il pointe vers l'adresse IP publique de l'équilibreur de charge. [LB_IP] représente l'adresse IP externe de l'instance backend.

REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders
REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products

Recompilez l'application de réaction, ce qui mettra à jour le code de l'interface.

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Copiez le code d'application dans le bucket GCS.

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Mettre à jour les instances frontend

Vous souhaitez maintenant que les instances frontend du groupe d'instances géré extraient le nouveau code. Vos instances extraient le code au démarrage afin que vous puissiez émettre une commande de redémarrage progressif.

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable 100%

Tester le site Web

Après l'exécution de la commande rolling-action restart, attendez environ 30 secondes le temps que les instances soient traitées. Vérifiez ensuite l'état du groupe d'instances géré jusqu'à ce que les instances apparaissent dans la liste.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Une fois que les éléments apparaissent dans la liste, quittez la commande watch en appuyant sur Control+C (Command+C sous Macintosh).

Vérifiez que le service est répertorié comme opérationnel.

watch -n 5 gcloud compute backend-services get-health fancy-fe-frontend --global

Exemple de résultat :

---
backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig
status:
  healthStatus:
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151
    ipAddress: 10.128.0.7
    port: 8080
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt
    ipAddress: 10.128.0.11
    port: 8080
  kind: compute#backendServiceGroupHealth

Une fois les éléments affichés dans la liste, quittez la commande watch en appuyant sur Control+C (Command+C sur Macintosh).

L'application sera alors accessible via http://[IP_D'ÉQUILIBREUR], où [IP_D'ÉQUILIBREUR] correspond à l'adresse IP spécifiée pour l'équilibreur de charge, que vous pouvez obtenir à l'aide de la commande suivante:

gcloud compute forwarding-rules list --global

7. Procéder au scaling de Compute Engine

Jusqu'à présent, vous avez créé deux groupes d'instances gérés, comportant chacun deux instances. La configuration est totalement fonctionnelle, mais est statique, quelle que soit la charge. Vous allez maintenant créer une règle d'autoscaling basée sur l'utilisation pour procéder au scaling automatique de chaque groupe d'instances géré.

Redimensionner automatiquement selon l'utilisation

Pour créer la règle d'autoscaling, exécutez les commandes suivantes dans Cloud Shell. Il créera un autoscaler sur les groupes d'instances gérés, qui ajoutera automatiquement des instances lorsque l'utilisation de l'équilibreur de charge dépassera 60% et supprimera des instances lorsque l'utilisation de l'équilibreur de charge sera inférieure à 60 %.

gcloud compute instance-groups managed set-autoscaling \
  fancy-fe-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

gcloud compute instance-groups managed set-autoscaling \
  fancy-be-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

Activer le réseau de diffusion de contenu

Une autre fonctionnalité pouvant faciliter le scaling consiste à activer Cloud CDN, un service réseau de diffusion de contenu, afin d'assurer la mise en cache du service frontend. Pour ce faire, vous pouvez exécuter la commande suivante sur votre service de frontend:

gcloud compute backend-services update fancy-fe-frontend \
    --enable-cdn --global

Désormais, lorsqu'un utilisateur demande du contenu à l'équilibreur de charge, la requête arrive à une interface Google, qui recherche d'abord une réponse à sa requête dans le cache Cloud CDN. Si l'interface trouve une réponse mise en cache, elle l'envoie à l'utilisateur. C'est ce qu'on appelle un succès de cache (hit).

Sinon, si l'interface ne trouve pas de réponse mise en cache pour la requête, elle envoie une requête directement au backend. Si la réponse à cette requête peut être mise en cache, l'interface la stocke dans le cache Cloud CDN afin que celui-ci puisse être utilisé pour les requêtes ultérieures.

8. Mettre à jour le site Web

Mettre à jour le modèle d'instance

Les modèles d'instances existants ne sont pas modifiables. Toutefois, comme vos instances sont sans état et que toute la configuration est effectuée via le script de démarrage, vous ne devez modifier le modèle d'instance que si vous souhaitez modifier l'image principale des paramètres du modèle. À présent, vous allez effectuer une modification simple pour utiliser un type de machine de capacité supérieure et déployer cette modification.

Mettez à jour l'instance frontend, qui sert de base au modèle d'instance. Lors de la mise à jour, vous allez placer un fichier sur la version mise à jour de l'image du modèle d'instance, mettre à jour le modèle d'instance, déployer le nouveau modèle et vérifier que le fichier existe bien sur les instances du groupe d'instances géré.

Vous modifierez le type de machine de votre modèle d'instance en passant du type de machine standard f1-micro à un type de machine personnalisé avec 4 vCPU et 3 840 Mio de RAM.

Dans Cloud Shell, exécutez la commande suivante pour modifier le type de machine de l'instance frontend:

gcloud compute instances set-machine-type frontend --machine-type custom-4-3840

Créez le modèle d'instance:

gcloud compute instance-templates create fancy-fe-new \
    --source-instance=frontend \
    --source-instance-zone=us-central1-a

Déployez le modèle d'instance mis à jour sur le groupe d'instances géré:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \
    --version template=fancy-fe-new

Surveillez l'état de la mise à jour:

watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig

Une fois que plusieurs instances ont l'état RUNNING (En cours d'exécution), ACTION défini sur None (Aucune) et INSTANCE_TEMPLATE défini comme nouveau nom de modèle (fancy-fe-new), copiez le nom de l'une des machines répertoriées pour l'utiliser dans la commande suivante.

Control+S (Command+S sur Macintosh) pour quitter le processus de visionnage.

Exécutez la commande suivante pour voir si la machine virtuelle utilise le nouveau type de machine (custom-4-3840), où [NOM_DE_VM] est l'instance que vous venez de créer :

gcloud compute instances describe [VM_NAME] | grep machineType

Exemple de résultat attendu :

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/us-central1-f/machineTypes/custom-4-3840

Apporter des modifications au site Web

Votre équipe marketing vous a demandé de modifier la page d'accueil de votre site. 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 satisfaire l'équipe marketing ! L'un de vos 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, copiez le fichier mis à jour sous le nom de fichier correct, puis imprimez son contenu 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 &amp; 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 install && npm run-script build

Ensuite, transférez à nouveau le code vers votre bucket Cloud Storage.

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Déployer les modifications avec des mises à jour progressives

Vous pouvez maintenant forcer le redémarrage de toutes les instances pour récupérer la mise à jour.

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable=100%

Attendez environ 30 secondes après l'exécution de la commande de redémarrage par action progressive afin de laisser le temps aux instances d'être traitées, puis vérifiez l'état du groupe d'instances géré jusqu'à ce que les instances apparaissent dans la liste.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Une fois les éléments affichés dans la liste, quittez la commande watch en appuyant sur Control+S (Command+S sous Macintosh).

Exécutez la commande suivante pour vérifier que le service est répertorié comme healthy (opérationnel) :

watch -n 5 gcloud compute backend-services get-health fancy-fe-frontend --global

Exemple de résultat :

---
backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig
status:
  healthStatus:
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151
    ipAddress: 10.128.0.7
    port: 8080
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt
    ipAddress: 10.128.0.11
    port: 8080
  kind: compute#backendServiceGroupHealth

Une fois que les éléments apparaissent dans la liste, quittez la commande watch en appuyant sur Control+S (Command+S sous Macintosh).

Pour invalider le contenu mis en cache dans le réseau de diffusion de contenu et vous assurer que du contenu récent s'affiche, exécutez la commande suivante:

gcloud compute url-maps invalidate-cdn-cache fancy-map \
    --path "/*"

Accédez au site Web via http://[IP_D'ÉQUILIBREUR], où [IP_D'ÉQUILIBREUR] correspond à l'adresse IP spécifiée pour l'équilibreur de charge. Vous pouvez la trouver à l'aide de la commande suivante:

gcloud compute forwarding-rules list --global

Les nouvelles modifications du site Web doivent maintenant être visibles.

Simuler une défaillance

Pour vous assurer que la vérification de l'état fonctionne, connectez-vous à une instance et arrêtez les services. Pour rechercher un nom d'instance, exécutez la commande suivante :

gcloud compute instance-groups list-instances fancy-fe-mig

Ensuite, Secure Shell pour accéder à l'une des instances, où INSTANCE_NAME est l'une des instances de la liste:

gcloud compute ssh [INSTANCE_NAME]

Dans l'instance, utilisez supervisorctl pour arrêter l'application.

sudo supervisorctl stop nodeapp; sudo killall node

Quittez l'instance.

exit

Surveiller les opérations de réparation

watch -n 5 gcloud compute operations list \
--filter='operationType~compute.instances.repair.*'

Recherchez l'exemple de résultat suivant :

NAME                                                  TYPE                                       TARGET                                 HTTP_STATUS  STATUS  TIMESTAMP
repair-1568314034627-5925f90ee238d-fe645bf0-7becce15  compute.instances.repair.recreateInstance  us-central1-a/instances/fancy-fe-1vqq  200          DONE    2019-09-12T11:47:14.627-07:00

Une fois la réparation détectée, utilisez Control+C (Command+S sur Macintosh) pour quitter la commande watch. À ce stade, le groupe d'instances géré recrée l'instance pour la réparer.

9. Effectuer un nettoyage

Une fois que vous êtes prêt, le moyen le plus simple de nettoyer toutes les activités effectuées consiste à supprimer le projet. La suppression du projet entraîne la suppression de l'équilibreur de charge, des instances, des modèles et des autres éléments créés au cours de l'atelier de programmation afin d'éviter des frais récurrents inattendus. Exécutez la commande suivante dans Cloud Shell, où PROJECT_ID correspond à l'ID complet du projet, et pas seulement au nom du projet.

gcloud projects delete [PROJECT_ID]

Confirmez la suppression en saisissant "Y" lorsque vous y êtes invité.

10. Félicitations !

Vous avez déployé, fait évoluer et mis à jour votre site Web sur Compute Engine. Vous savez maintenant utiliser Compute Engine, les groupes d'instances gérés, l'équilibrage de charge et les vérifications de l'état.