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

Déployer une application Web en conteneur

Ce tutoriel explique comment empaqueter une application Web dans une image de conteneur Docker et exécuter cette image sur un cluster Google Kubernetes Engine (GKE). Vous déployez ensuite l'application Web sous la forme d'un ensemble d'instances dupliquées à équilibrage de charge pouvant s'adapter aux besoins de vos utilisateurs.

Cette page est destinée aux opérateurs et aux développeurs qui provisionnent et configurent des ressources cloud, et déploient des applications et des services. Pour en savoir plus sur les rôles courants et les exemples de tâches que nous citons dans le contenu Google Cloud, consultez la section Rôles utilisateur et tâches courantes de l'utilisateur dans GKE Enterprise.

Objectifs

Empaqueter un exemple d'application Web dans une image Docker
importer l'image Docker dans Artifact Registry ;
créer un cluster GKE ;
déployer l'application exemple sur le cluster ;
gérer l'autoscaling pour le déploiement ;
exposer l'application exemple sur Internet ;
Déployer une nouvelle version de l'exemple d'application

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.

Enable the APIs

Activer Cloud Shell

Cloud Shell est préinstallé sur les outils de ligne de commande gcloud, docker et kubectl utilisés dans ce tutoriel.

Accédez à Google Cloud Console.
Cliquez sur le bouton Activer Cloud Shell en haut de la fenêtre de la console Google Cloud.

Une session Cloud Shell s'ouvre dans un nouveau cadre en bas de la console Google Cloud et affiche une invite de ligne de commande.

Créer un dépôt

Dans ce tutoriel, vous allez stocker une image dans Artifact Registry et la déployer à partir du registre. Pour ce guide de démarrage rapide, vous allez créer un dépôt nommé hello-repo.

Définissez la variable d'environnement PROJECT_ID sur votre ID de projet Google Cloud (PROJECT_ID). Cette variable d'environnement vous sera utile lorsque vous créerez l'image de conteneur et que vous la transférerez vers votre dépôt.
```
export PROJECT_ID=PROJECT_ID
```
Vérifiez que la valeur de la variable d'environnement PROJECT_ID est correcte :
```
echo $PROJECT_ID
```
Définissez votre ID de projet pour Google Cloud CLI :
```
gcloud config set project $PROJECT_ID
```
Sortie :
```
Updated property [core/project].
```
Remarque : Votre gcloud CLI est peut-être déjà défini sur votre $PROJECT_ID. Vous verrez alors toujours le résultat Updated property.
Créez le dépôt hello-repo à l'aide de la commande suivante :
```
gcloud artifacts repositories create hello-repo \
   --repository-format=docker \
   --location=REGION \
   --description="Docker repository"
```
Remplacez REGION par la région du dépôt, par exemple us-west1. Pour afficher la liste des emplacements disponibles, exécutez la commande suivante :
```
 gcloud artifacts locations list
```

Créer l'image du conteneur

Dans ce tutoriel, vous allez déployer un exemple d'application Web appelé hello-app. Il s'agit d'un serveur Web écrit en Go qui répond à toutes les requêtes avec le message Hello, World! sur le port 8080.

GKE accepte les images Docker comme format de déploiement de l'application. Avant de déployer hello-app sur GKE, vous devez empaqueter le code source de hello-app en tant qu'image Docker.

Pour créer une image Docker, vous avez besoin du code source et d'un fichier Dockerfile. Un fichier Dockerfile contient des instructions sur la création de l'image.

Téléchargez le code source et le fichier Dockerfile de hello-app en exécutant les commandes suivantes :

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/quickstarts/hello-app

Créez l'image Docker de hello-app et ajoutez un tag comme suit :
```
docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 .
```
Cette commande indique à Docker qu'il doit créer l'image à l'aide du fichier Dockerfile dans le répertoire actuel, l'enregistrer dans votre environnement local et lui attribuer un nom tel que us-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1. L'image est transférée vers Artifact Registry dans la section suivante.
- La variable PROJECT_ID associe l'image de conteneur au dépôt hello-repo de votre projet Google Cloud.
- Le préfixe us-west1-docker.pkg.dev fait référence à Artifact Registry, hôte régional de votre dépôt.
Remarque : Si vous y êtes invité, autorisez Cloud Shell à effectuer des appels d'API Google Cloud.

Exécutez la commande docker images pour vérifier que la compilation a réussi :

docker images

Sortie :

REPOSITORY                                                 TAG     IMAGE ID       CREATED          SIZE
us-west1-docker.pkg.dev/my-project/hello-repo/hello-app    v1      25cfadb1bf28   10 seconds ago   54 MB

Ajoutez des liaisons de stratégie IAM à votre compte de service :

gcloud artifacts repositories add-iam-policy-binding hello-repo \
    --location=REGION \
    --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
    --role="roles/artifactregistry.reader"

Remplacez PROJECT_NUMBER par le numéro de votre projet.

Exécuter le conteneur localement (facultatif)

Testez votre image de conteneur à l'aide de votre moteur Docker local :

docker run --rm -p 8080:8080 REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1

Cliquez sur le bouton Aperçu sur le Web , puis sélectionnez le numéro de port 8080. GKE ouvre l'URL d'aperçu sur son service proxy dans une nouvelle fenêtre de navigateur.

Transférer l'image Docker dans Artifact Registry

Vous devez importer l'image de conteneur dans un registre afin que votre cluster GKE puisse la télécharger et l'exécuter. Dans ce tutoriel, vous allez stocker votre conteneur dans Artifact Registry.

Configurez l'outil de ligne de commande Docker pour qu'il s'authentifie auprès d'Artifact Registry :
```
gcloud auth configure-docker REGION-docker.pkg.dev
```
Remarque : Vous pouvez ignorer les avertissements concernant la présence d'une longue liste d'assistants d'identification.

Transférez l'image Docker que vous venez de créer vers le dépôt :

docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1

Créer un cluster GKE

Maintenant que l'image Docker est stockée dans Artifact Registry, créez un cluster GKE pour exécuter hello-app. Un cluster GKE est constitué d'un pool d'instances de VM Compute Engine exécutant Kubernetes, le système d'orchestration de clusters Open Source exploité par GKE.

Cloud Shell

Définissez votre région Compute Engine :
```
 gcloud config set compute/region REGION
```
Pour les clusters zonaux en mode Standard, définissez la zone Compute Engine la plus proche du dépôt Artifact Registry.
Créez un cluster nommé hello-cluster :
```
 gcloud container clusters create-auto hello-cluster
```
La création et la vérification de l'état de votre cluster GKE peuvent prendre quelques minutes. Pour exécuter ce tutoriel sur un cluster GKE Standard, utilisez plutôt la commande gcloud container clusters create.

Console

Accédez à la page Google Kubernetes Engine dans Google Cloud Console.

Accéder à Google Kubernetes Engine
Cliquez sur Créer.
Pour GKE Autopilot, cliquez sur Configurer.
Dans le champ Nom, saisissez le nom hello-cluster.
Sélectionnez une région Compute Engine dans la liste déroulante Région, telle que us-west1.
Cliquez sur Créer.
Attendez que le cluster soit créé. Lorsque le cluster est prêt, une coche apparaît à côté de son nom.

Déployer l'exemple d'application sur GKE

Vous êtes maintenant prêt à déployer l'image Docker que vous avez créée sur votre cluster GKE.

Kubernetes représente les applications sous forme de pods, qui sont des unités évolutives contenant un ou plusieurs conteneurs. Le pod est la plus petite unité déployable dans Kubernetes. Généralement, vous déployez les pods sous la forme d'un ensemble d'instances dupliquées pouvant être mises à l'échelle et réparties sur votre cluster. Pour déployer un ensemble d'instances dupliquées, vous pouvez utiliser un déploiement Kubernetes.

Dans cette section, vous allez créer un déploiement Kubernetes pour exécuter hello-app sur votre cluster. Ce déploiement possède des instances dupliquées (pods). Un pod de déploiement ne contient qu'un seul conteneur : l'image Docker hello-app. Vous allez également créer une ressource HorizontalPodAutoscaler qui adapte le nombre de pods et le fait passer de 3 à un nombre compris entre 1 et 5, en fonction de la charge du processeur.

Cloud Shell

Assurez-vous d'être connecté à votre cluster GKE.

gcloud container clusters get-credentials hello-cluster --region REGION

Créez un déploiement Kubernetes pour votre image Docker hello-app.

kubectl create deployment hello-app --image=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1

Définissez le nombre de référence d'instances dupliquées de déploiement sur 3.
```
kubectl scale deployment hello-app --replicas=3
```

Créez une ressource HorizontalPodAutoscaler pour votre déploiement.

kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5

Pour afficher les pods créés, exécutez la commande suivante :

kubectl get pods

Sortie :

NAME                         READY   STATUS    RESTARTS   AGE
hello-app-784d7569bc-hgmpx   1/1     Running   0          90s
hello-app-784d7569bc-jfkz5   1/1     Running   0          90s
hello-app-784d7569bc-mnrrl   1/1     Running   0          95s

Console

Accédez à la page Charges de travail dans la console Google Cloud.

Accéder à la page Charges de travail
Cliquez sur Déployer.
Dans la section Spécifier un conteneur, sélectionnez Image existante du conteneur.
Dans le champ Chemin de l'image, cliquez sur Sélectionner.
Dans le volet Sélectionner l'image du conteneur, sélectionnez l'image hello-app que vous avez envoyée à Artifact Registry, puis cliquez sur Sélectionner.
Dans la section Conteneur, cliquez sur OK, puis sur Continuer.
Dans la section Configuration, sous Libellés, saisissez app pour Clé et hello-app pour Valeur.
Sous Configuration YAML, cliquez sur Afficher YAML. Un fichier de configuration YAML s'ouvre. Il représente les deux ressources de l'API Kubernetes sur le point d'être déployées dans votre cluster : un déploiement et sa ressource HorizontalPodAutoscaler.
Cliquez sur Fermer, puis sur Déployer.
Lorsque les pods de déploiement sont prêts, la page Informations sur le déploiement s'affiche.
Sous Pods gérés, notez les trois pods en cours d'exécution pour le déploiement hello-app.

Exposer l'exemple d'application sur Internet

Bien que des adresses IP individuelles soient attribuées aux pods, ces adresses IP ne sont accessibles qu'à partir de votre cluster. En outre, les pods GKE sont conçus pour être éphémères, et démarrer ou s'arrêter en fonction des besoins du scaling. Et lorsqu'un pod se bloque en raison d'une erreur, GKE le redéploie automatiquement en lui attribuant une nouvelle adresse IP.

Cela signifie que pour tout déploiement, l'ensemble d'adresses IP correspondant à l'ensemble actif de pods est dynamique. Nous avons besoin d'un moyen de 1) regrouper les pods sous un nom d'hôte statique et 2) d'exposer un groupe de pods à l'extérieur du cluster, sur Internet.

Les services Kubernetes permettent de résoudre ces deux problèmes. Les services regroupent les pods sous une seule adresse IP statique, accessible depuis n'importe quel pod du cluster. GKE attribue également un nom d'hôte DNS à cette adresse IP statique. Par exemple, hello-app.default.svc.cluster.local.

Le type de service par défaut dans GKE est appelé ClusterIP, où le service obtient une adresse IP accessible uniquement à partir du cluster. Pour exposer un service Kubernetes en dehors du cluster, créez un service de LoadBalancer. Ce type de service génère une adresse IP d'équilibreur de charge externe pour un ensemble de pods, accessible via Internet.

Dans cette section, vous exposez le déploiement hello-app sur Internet à l'aide d'un service de type LoadBalancer.

Cloud Shell

Utilisez la commande kubectl expose pour générer un service Kubernetes pour le déploiement hello-app :
```
kubectl expose deployment hello-app --name=hello-app-service --type=LoadBalancer --port 80 --target-port 8080
```
Ici, l'option --port spécifie le numéro de port configuré sur l'équilibreur de charge, et l'option --target-port spécifie le numéro de port sur lequel le conteneur hello-app écoute.

Exécutez la commande suivante pour obtenir les détails du service pour hello-app-service :

kubectl get service

Sortie :

NAME                 CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
hello-app-service    10.3.251.122    203.0.113.0     80:30877/TCP     10s

Copiez l'adresse EXTERNAL_IP dans le presse-papiers (par exemple, 203.0.113.0).

Remarque : Le provisionnement de l'équilibreur de charge peut prendre quelques minutes. Tant que l'équilibreur de charge n'est pas provisionné, une adresse IP <pending> peut s'afficher.

Console

Accédez à la page Charges de travail dans la console Google Cloud.

Accéder à la page Charges de travail
Cliquez sur hello-app.
Sur la page "Informations sur le déploiement", cliquez sur Actions > Exposer.
Dans la boîte de dialogue Exposer, définissez le port cible sur 8080. Il s'agit du port sur lequel le conteneur hello-app écoute.
Dans la liste déroulant Type de service, sélectionnez Équilibreur de charge.
Cliquez sur Exposer afin de créer un service Kubernetes pour hello-app.
Lorsque l'équilibreur de charge est prêt, la page Informations sur le service s'ouvre.
Faites défiler la page jusqu'au champ Points de terminaison externes, puis copiez l'adresse IP.

Maintenant que les pods hello-app sont exposés sur Internet via un service Kubernetes, vous pouvez ouvrir un nouvel onglet de navigateur et accéder à l'adresse IP du service que vous avez copiée dans le presse-papiers. Un message Hello, World! s'affiche, accompagné d'un champ Hostname. Le nom d'hôte (Hostname) correspond à l'un des trois pods hello-app qui diffusent votre requête HTTP dans votre navigateur.

Déployer une nouvelle version de l'exemple d'application

Dans cette section, vous allez mettre à niveau hello-app vers une nouvelle version en créant et en déployant une nouvelle image Docker sur votre cluster GKE.

La mise à jour progressive de Kubernetes vous permet de mettre à jour vos déploiements sans temps d'arrêt. Lors d'une mise à jour progressive, votre cluster GKE remplace progressivement les pods hello-app existants par des pods contenant l'image Docker pour la nouvelle version. Pendant la mise à jour, votre service d'équilibrage de charge n'achemine le trafic que vers les pods disponibles.

Revenez dans Cloud Shell, où vous avez cloné le code source et le fichier Dockerfile de hello-app. Mettez à jour la fonction hello() dans le fichier main.go pour signaler la nouvelle version 2.0.0.

Créez une nouvelle image Docker pour hello-app et ajoutez-y un tag.

docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 .

Transférer l'image vers Artifact Registry

docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2

Vous êtes maintenant prêt à mettre à jour le déploiement Kubernetes de hello-app pour utiliser une nouvelle image Docker.

Cloud Shell

Appliquez une mise à jour progressive du déploiement hello-app existant avec une mise à jour d'image à l'aide de la commande kubectl set image :
```
kubectl set image deployment/hello-app hello-app=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
```

Observez les pods en cours d'exécution utilisant l'image v1 s'arrêter, et les nouveaux pods utilisant l'image v2 démarrer.

watch kubectl get pods

Sortie :

NAME                        READY   STATUS    RESTARTS   AGE
hello-app-89dc45f48-5bzqp   1/1     Running   0          2m42s
hello-app-89dc45f48-scm66   1/1     Running   0          2m40s

Dans un autre onglet, accédez de nouveau à l'adresse IP externe hello-app-service. La Version doit maintenant être définie sur 2.0.0..

Console

Accédez à la page Charges de travail dans la console Google Cloud.

Accéder à la page Charges de travail
Cliquez sur hello-app.
Sur la page Informations sur le déploiement, cliquez sur Actions > Mise à jour progressive.
Dans la boîte de dialogue Mise à jour progressive, définissez le champ Image de hello-app sur REGION-docker.pkg.dev/PROJECT_ID/hello-repo/hello-app:v2.
Cliquez sur Mettre à jour.
Sur la page Informations sur le déploiement, inspectez la section Révisions actives. Vous devriez maintenant voir deux révisions, 1 et 2. La révision 1 correspond au déploiement initial que vous avez créé précédemment. La révision 2 correspond à la mise à jour progressive que vous venez de démarrer.
Après quelques instants, actualisez la page. Sous Pods gérés, toutes les instances dupliquées de hello-app correspondent désormais à la révision 2.
Dans un autre onglet, accédez de nouveau à l'adresse IP du service que vous avez copiée. La Version doit être définie sur 2.0.0..

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimez le service : cette étape annule l'allocation de l'équilibreur de charge Cloud créé pour le service :
```
kubectl delete service hello-app-service
```
Supprimez le cluster : cette étape supprime les ressources qui constituent le cluster, telles que les instances de calcul, les disques et les ressources réseau :
```
gcloud container clusters delete hello-cluster --region REGION
```

Supprimer vos images de conteneurs : cette étape supprime les images Docker que vous avez transférées vers Artifact Registry.

gcloud artifacts docker images delete \
    REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 \
    --delete-tags --quiet
gcloud artifacts docker images delete \
    REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 \
    --delete-tags --quiet

Étape suivante

Découvrez les tarifs de GKE et utilisez le simulateur de coût pour estimer les coûts.
Lisez le tutoriel sur les équilibreurs de charge, qui présente des configurations avancées d'équilibrage de charge pour les applications Web.
Configurez l'adresse IP statique et le nom de domaine de votre application.
Découvrez d'autres tutoriels Kubernetes Engine.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.

Faites l'essai

Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de GKE en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

Profiter d'un essai gratuit de GKE