1. Avant de commencer
L'exécution de sites Web peut s'avérer difficile en raison des frais généraux liés à la création et à la gestion d'instances de machines virtuelles (VM), de clusters, de pods, de services, etc. Cela convient pour les applications plus volumineuses à plusieurs niveaux, mais si vous souhaitez simplement que votre site Web soit déployé et visible, cela représente beaucoup de frais généraux.
Avec Cloud Run, la mise en œuvre Google Cloud de Knative, vous pouvez gérer et déployer votre site Web sans les frais généraux dont vous avez besoin pour les déploiements basés sur des VM ou sur Kubernetes. Il s'agit non seulement d'une approche plus simple du point de vue de la gestion, mais cela vous permet également d'effectuer un scaling à zéro instance lorsqu'aucune demande n'arrive sur votre site Web.
Cloud Run intègre non seulement le développement sans serveur aux conteneurs, mais il peut également être exécuté sur vos propres clusters Google Kubernetes Engine (GKE) ou sur une solution Platform as a Service (PaaS) entièrement gérée fournie par Cloud Run. Vous testerez ce dernier scénario dans cet atelier de programmation.
Le schéma suivant illustre le déroulement du déploiement et de l'hébergement Cloud Run. Vous commencerez avec une image Docker créée via Cloud Build, que vous déclencherez dans Cloud Shell. Vous déploierez ensuite cette image dans Cloud Run à l'aide d'une commande dans Cloud Shell.
Prérequis
- Connaissances générales de Docker (consultez la section Premiers pas du site Web de Docker)
Points abordés
- Créer une image Docker avec Cloud Build et l'importer dans gcr.io
- Le déploiement d'images Docker dans Cloud Run
- La gestion des déploiements dans Cloud Run
- Configurer un point de terminaison pour une application dans Cloud Run
Ce que vous allez faire
- Un site Web statique qui s'exécute dans un conteneur Docker
- Une version de ce conteneur qui se trouve dans Container Registry
- Un déploiement Cloud Run pour votre site Web statique
Prérequis
- Un compte Google avec un accès administrateur permettant de créer des projets ou un projet avec le rôle de propriétaire de projet
2. Cofiguration de l'environnement
Configuration de l'environnement au rythme de chacun
Si vous n'avez pas encore de compte Google, vous devez en créer un. Connectez-vous ensuite à la console Google Cloud, puis cliquez sur Projet > Créer un projet
Notez l'ID du projet, qui est automatiquement renseigné sous le nom de votre projet. L'ID du projet est un nom unique parmi tous les projets Google Cloud. Par conséquent, le nom figurant sur la capture d'écran a déjà été pris et ne fonctionnera pas dans votre cas. Elle sera désignée plus tard par le nom PROJECT_ID.
Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources Google Cloud et activer l'API Cloud Run.
Activer l'API Cloud Run
Cliquez sur le menu de navigation événements > API et Services > Tableau de bord > Activez les API et les services. .
Recherchez "API Cloud Run" Cliquez ensuite sur API Cloud Run > Activer :
L'exécution de cet atelier de programmation ne devrait pas vous coûter plus que quelques dollars, mais ce montant peut être plus élevé si vous décidez d'utiliser plus de ressources ou de continuer à les exécuter (consultez la section Effectuer un nettoyage à la fin). Pour en savoir plus, reportez-vous à la section Tarifs.
Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais de 300$.
Cloud Shell
Bien que Google Cloud et Cloud Run puissent être utilisés à distance depuis votre ordinateur portable, vous allez utiliser Cloud Shell, un environnement de ligne de commande exécuté dans Google Cloud. L'environnement est préconfiguré avec toutes les bibliothèques clientes et tous les frameworks dont vous avez besoin.
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 la page Régions et zones.
3. Cloner le dépôt source
Étant donné que vous déployez un site Web existant, il vous suffit de cloner la source depuis votre dépôt. Vous pouvez ainsi vous concentrer sur la création d'images Docker et sur le déploiement sur Cloud Run.
Exécutez les commandes suivantes pour cloner le dépôt dans votre instance Cloud Shell et accéder au répertoire approprié. Vous allez également installer les dépendances Node.js afin de pouvoir tester votre application avant son déploiement.
cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices ./setup.sh
Cette opération clone votre dépôt, change de répertoire et installe les dépendances nécessaires à l'exécution locale de votre application. L'exécution du 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
Sortie :
Monolith listening on port 8080!
Vous pouvez prévisualiser votre application en cliquant sur Aperçu sur le Web
et en sélectionnant Prévisualiser sur le port 8080.
Une nouvelle fenêtre s'affiche, dans laquelle vous pouvez voir votre Fancy Store en action.
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 un conteneur Docker avec Cloud Build
Maintenant que vos fichiers sources sont prêts à être utilisés, il est temps de déployer votre application dans un conteneur Docker.
Normalement, vous devriez adopter une approche en deux étapes consistant à créer un conteneur Docker et à le transférer vers un registre afin de stocker l'image pour que GKE puisse l'extraire. Cependant, 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 commande. Pour découvrir le processus manuel de création et de transfert d'un Dockerfile, 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 tous les fichiers du bucket et utilise le Dockerfile, qui se trouve dans le même répertoire 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 sera transférée vers Container Registry.
Tout d'abord, vous devez vous assurer que l'API Cloud Build est activée. Exécutez la commande suivante pour l'activer :
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:
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 .
Ce processus prend quelques minutes, mais une fois terminé, vous obtenez un résultat semblable à celui-ci 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 observer le processus en temps réel, vous pouvez accéder à la console Cloud, puis cliquer sur le menu de navigation événements > Cloud Build > Historique. Vous pouvez alors voir la liste de toutes vos compilations précédentes, mais vous ne devriez voir que celle que vous avez créée.
Si vous cliquez sur l'ID de la compilation, vous pouvez consulter tous les détails de cette compilation, y compris la sortie du journal. Vous pouvez afficher l'image de conteneur créée en cliquant sur le lien à côté d'Image.
5. Déployer un conteneur dans Cloud Run
Maintenant que vous avez conteneurisé votre site Web et l'avez transféré vers Container Registry, il est temps de le déployer sur Cloud Run.
Deux approches sont possibles pour le déploiement dans Cloud Run :
- Cloud Run (entièrement géré) est le modèle PaaS dans lequel l'intégralité du cycle de vie des conteneurs est gérée. C'est cette approche que vous utiliserez dans cet atelier de programmation.
- Cloud Run for Anthos est Cloud Run avec une couche de contrôle supplémentaire, qui vous permet d'importer vos clusters et pods depuis GKE. Pour en savoir plus, consultez la page Configurer Cloud Run pour Anthos sur Google Cloud.
Les exemples de ligne de commande seront disponibles dans Cloud Shell à l'aide des variables d'environnement que vous avez configurées précédemment.
Ligne de commande
Exécutez la commande suivante pour déployer votre application :
gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed
Vous devez indiquer la région dans laquelle vous souhaitez effectuer l'exécution. Sélectionnez la région la plus proche de vous, puis acceptez le nom de service suggéré par défaut (monolith).
À des fins de test, autorisez les requêtes non authentifiées adressées à l'application. Saisissez y à l'invite.
Vérifier le déploiement
Pour vérifier que le déploiement a bien été créé, exécutez la commande suivante. Il peut s'écouler quelques instants avant que Pod status passe à Running:
gcloud run services list
Sélectionnez [1] Cloud Run (entièrement géré).
Sortie :
SERVICE REGION URL LAST DEPLOYED BY LAST DEPLOYED AT ✔ monolith us-east1 <your url> <your email> 2019-09-16T21:07:38.267Z
La sortie vous indique plusieurs choses. Vous pouvez voir votre déploiement, l'utilisateur qui l'a déployé (votre adresse e-mail) et l'URL que vous pouvez utiliser pour accéder à l'application. Il semble que tous les éléments ont bien été créés.
Ouvrez l'URL fournie dans la liste des services de votre navigateur Web. Vous devriez voir le même site Web que celui dont vous avez affiché l'aperçu localement.
6. Créer une révision avec une simultanéité inférieure
Maintenant, déployez à nouveau votre application, mais cette fois, ajustez l'un des paramètres.
Par défaut, une application Cloud Run a une valeur de simultanéité de 80, ce qui signifie que chaque instance de conteneur traite jusqu'à 80 requêtes à la fois. Il s'agit d'un écart important par rapport au modèle FaaS (Functions as a Service), dans lequel une instance traite une requête à la fois.
Redéployez la même image de conteneur avec une valeur de simultanéité correspondant à 1 (à des fins de test uniquement) et observez le résultat.
gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed --concurrency 1
Répondez aux questions suivantes comme vous l'avez fait la première fois. Une fois la commande exécutée, accédez à la console Cloud pour voir le résultat.
Dans le tableau de bord Cloud Run, cliquez sur le service monolith pour afficher les détails.
Cliquez sur l'onglet Révisions. Vous devriez voir deux révisions créées. Cliquez sur monolith-00002 et vérifiez les détails. La valeur de simultanéité doit être réduite à 1.
]
Bien que cette configuration soit suffisante pour les tests, dans la plupart des scénarios de production, les conteneurs prennent en charge plusieurs requêtes simultanées.
Maintenant, restaurez la simultanéité d'origine sans redéployer. Vous pouvez définir la valeur de simultanéité par défaut de 80 ou 0, ce qui supprimera toutes les restrictions de simultanéité et la définira sur le maximum par défaut (qui se trouve être 80 au moment de la rédaction de cet article).
Exécutez la commande suivante dans Cloud Shell pour mettre à jour la révision actuelle:
gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed --concurrency 80
Notez qu'une autre révision a été créée, que le trafic a été redirigé et que la simultanéité est revenue à la valeur 80.
7. Apporter des modifications au site Web
Votre équipe marketing vous a demandé de modifier la page d'accueil du site Web de votre entreprise. Il pense qu'elle devrait fournir plus d'informations sur ce qu'est l'entreprise et ce qu'elle vend. Dans cette section, vous allez ajouter du texte à la page d'accueil pour satisfaire l'équipe marketing !
Il semble que l'un de vos développeurs a déjà créé les modifications avec le nom de fichier index.js.new. Il vous suffit de copier ce fichier dans index.js pour répercuter vos modifications. Suivez les instructions pour apporter les modifications appropriées.
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 & 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 est 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, vous mettrez à jour le libellé 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 .
Dans la section suivante, vous utiliserez cette image pour mettre à jour votre application sans aucun temps d'arrêt.
8. Mettre à jour le site Web sans aucun temps d'arrêt
Les modifications ont été effectuées, puis validées par l'équipe marketing. Il est temps de mettre à jour le site Web sans interrompre le travail des utilisateurs.
Cloud Run traite chaque déploiement comme une nouvelle révision, qui est mise en ligne, puis le trafic est redirigé vers celle-ci.
Suivez les instructions ci-dessous pour mettre à jour votre site Web.
Ligne de commande
À partir de la ligne de commande, vous pouvez redéployer le service pour mettre à jour l'image vers une nouvelle version à l'aide de la commande suivante:
gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 --platform managed
Vérifier le déploiement
Validez la mise à jour de votre déploiement en exécutant la commande suivante:
gcloud run services describe monolith --platform managed
Le résultat ressemble à ceci :
apiVersion: serving.knative.dev/v1alpha1
kind: Service
metadata:
annotations:
client.knative.dev/user-image: gcr.io/my-cloudrun-codelab/monolith:2.0.0
...
Vous verrez que votre service utilise désormais la dernière version de votre image déployée dans une nouvelle révision.
Pour vérifier vos modifications, accédez de nouveau à l'URL externe de votre service Cloud Run. Notez que le titre de votre application a été mis à jour.
Exécutez la commande suivante pour lister les services et afficher l'adresse IP si vous l'avez oubliée:
gcloud run services list
Votre site Web devrait maintenant afficher le texte que vous avez ajouté au composant de la page d'accueil.
9. Effectuer un nettoyage
Supprimer des images Container Registry
# 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
# 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 Cloud Run
gcloud run services delete monolith --platform managed
10. Félicitations
Vous avez déployé, mis à l'échelle et mis à jour votre site Web avec Cloud Run.