Ce didacticiel vous montre comment empaqueter une application Web dans une image de conteneur Docker et exécuter cette image de conteneur sur un cluster Google Kubernetes Engine (GKE). Ensuite, vous déployez l'application Web en tant qu'ensemble de répliques à charge équilibrée qui peut s'adapter aux besoins de vos utilisateurs.

## Objectifs
- Empaqueter un exemple d'application Web dans une image Docker

- Téléchargez l'image Docker dans Artifact Registry

- Créer un cluster GKE

- Déployer l'exemple d'application sur le cluster

- Gérer l'autoscaling pour le déploiement

- Exposez l'exemple d'application à Internet

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

## Frais
Ce tutoriel utilise les composants facturables suivants de Google Cloud :
Pour générer une estimation des coûts en fonction de votre utilisation prévue,
utiliser le calculateur de prix

Lorsque vous avez terminé ce didacticiel, vous pouvez éviter la poursuite de la facturation en supprimant les ressources que vous avez créées. Pour plus d'informations, voir Nettoyer

## Avant de commencerSuivez les étapes suivantes pour activer l'API Kubernetes Engine :
- Connectez-vous à votre compte Google Cloud. Si vous débutez avec Google Cloud, créez un compte pour évaluer les performances de nos produits dans des scénarios réels. Les nouveaux clients bénéficient également de 300 USD de crédits gratuits pour exécuter, tester et déployer des charges de travail

-
Dans la console Google Cloud, sur la page de sélection de projet, sélectionnez ou créez un projet Google Cloud

-
Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet

-
Activer les API Artifact Registry et Google Kubernetes Engine

-
Dans la console Google Cloud, sur la page de sélection de projet, sélectionnez ou créez un projet Google Cloud

-
Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet

-
Activer les API Artifact Registry et Google Kubernetes Engine

 Option A : Utiliser Cloud Shell
Vous pouvez suivre ce tutoriel à l'aide de Cloud Shell, qui vient
préinstallé avec le
gcloud,
docker, et
outils de ligne de commande kubectl utilisés
dans ce tutoriel. Si vous utilisez Cloud Shell, vous n'avez pas besoin d'installer ces
outils de ligne de commande sur votre poste de travail

Pour utiliser Cloud Shell :
- Accédez à la console Google Cloud

Clique le
Activer Cloud Shell
bouton en haut de la fenêtre de la console Google Cloud

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

 Option B : Utiliser les outils de ligne de commande localement
Si vous préférez suivre ce tutoriel sur votre poste de travail, suivez ces étapes pour installer les outils nécessaires

Installer l'interface de ligne de commande Google Cloud

À l'aide de l'interface de ligne de commande gcloud, installez l'outil de ligne de commande Kubernetes
kubectlis est utilisé pour communiquer avec Kubernetes, qui est le système d'orchestration de cluster des clusters GKE :
composants gcloud installer kubectl
Installez Docker Community Edition (CE) sur votre poste de travail. Vous l'utilisez pour créer une image de conteneur pour l'application

Installez l'outil de contrôle de source Git pour récupérer l'exemple d'application à partir de GitHub

## Créer un référentiel
Dans ce didacticiel, vous allez stocker une image dans Artifact Registry et la déployer
du registre. Artifact Registry est le registre de conteneurs recommandé sur
Google Cloud. Pour ce démarrage rapide, vous allez créer un dépôt nommé
bonjour-repo

Met le
variable d'environnement PROJECT_ID à votre ID de projet Google Cloud (
). Vous utiliserez cette variable d'environnement lorsque vous créerez l'image du conteneur et la transférerez dans votre référentiel

PROJET_ID
exporter PROJECT_ID=
PROJET_ID
Confirmez que le
La variable d'environnement PROJECT_ID a la bonne valeur :
écho $PROJECT_ID
Définissez votre ID de projet pour la CLI Google Cloud :
Projet d'ensemble de configuration gcloud $PROJECT_ID
Production:
Propriété mise à jour [noyau/projet]

Créer le
hello-reporepository avec la commande suivante :
Les dépôts d'artefacts gcloud créent hello-repo \ --repository-format=docker \ --location=
REGION\ --description="Dépôt Docker"Remplacer
avec la région du référentiel, par exemple
RÉGION
us-west1. Pour afficher la liste des emplacements disponibles, exécutez la commande :
liste des emplacements des artefacts gcloud
## Construire l'image du conteneur
Dans ce didacticiel, vous déployez un exemple de site Web
application appelée
hello-app, un serveur web écrit
dans Go qui répond à toutes les requêtes avec le message
Bonjour le monde! sur le port 8080

GKE accepte les images Docker comme format de déploiement d'application

Avant de déployer
hello-app à GKE, vous devez empaqueter
le
code source hello-app en tant qu'image Docker

Pour créer une image Docker, vous avez besoin du code source et d'un Dockerfile. Un Dockerfile contient des instructions sur la façon dont l'image est construite

Télécharger le
hello-appsource code et Dockerfile en exécutant les commandes suivantes :
git clone httpsgithub.com/GoogleCloudPlatform/kubernetes-engine-samples cd kubernetes-engine-samples/hello-app
Créez et étiquetez l'image Docker pour
bonjour-app :
docker build -t
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1

Cette commande demande à Docker de créer l'image à l'aide du
Dockerfiledans le répertoire actuel, enregistrez-le dans votre environnement local et étiquetez-le avec un nom, tel que
us-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1. L'image est transmise à Artifact Registry dans la section suivante.

- Le
La variable PROJECT_ID associe l'image du conteneur à la
hello-reporepository dans votre projet Google Cloud

- Le
us-west1-docker.pkg.devprefix fait référence à Artifact Registry, l'hôte régional de votre dépôt

- Le
Exécutez le
docker imagescommand pour vérifier que la compilation a réussi :
images de docker
Production:
REPOSITORY TAG IMAGE ID CREATED SIZE us-west1-docker.pkg.dev/my-project/hello-repo/hello-app v1 25cfadb1bf28 il y a 10 secondes 54 MB
## Exécuter votre conteneur localement (facultatif)
Testez votre image de conteneur à l'aide de votre moteur Docker local :
docker run --rm -p 8080:8080
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1
Si vous utilisez Cloud Shell, cliquez sur le
Bouton Aperçu 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

Sinon, ouvrez une nouvelle fenêtre de terminal (ou un onglet Cloud Shell) et exécutez la commande suivante pour vérifier que le conteneur fonctionne et répond aux requêtes avec "Hello, World
curl httplocalhost:8080
Une fois que vous avez vu une réponse positive, vous pouvez fermer le conteneur en appuyant sur
Ctrl+Cdans l'onglet où se trouve le
docker runcommand est en cours d'exécution

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

Configurez l'outil de ligne de commande Docker pour vous authentifier auprès d'Artifact Registry :
gcloud auth configure-docker
REGION-docker.pkg.dev
Transférez l'image Docker que vous venez de créer dans le dépôt :
docker poussée
REGION-docker.pkg.devPROJECT_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 GKE
groupe
courir
bonjour-app. Un cluster GKE se compose d'un pool d'instances de VM Compute Engine
exécutant Kubernetes, l'orchestration de cluster open source
système qui alimente GKE

 Coquille de nuage
Définissez votre zone ou région Compute Engine. Selon le mode de fonctionnement que vous choisissez d'utiliser dans GKE, spécifiez une zone ou une région par défaut. Si vous utilisez le mode Standard, votre cluster est zonal (pour ce didacticiel), définissez donc votre zone de calcul par défaut. Si vous utilisez le mode Autopilot, votre cluster est régional, définissez donc votre région de calcul par défaut. Choisissez une zone ou une région la plus proche du dépôt Artifact Registry que vous avez créé

Standardcluster, tel que
us-west1-a :
gcloud config set calcul/zone
COMPUTE_ZONE cluster de pilote automatique, tel que
us-west1 :
gcloud config set calcul/région
COMPUTE_REGION
-
Créez un cluster nommé
hello-cluster :
Cluster standard :
les clusters de conteneurs gcloud créent un cluster hello
Cluster Pilote automatique :
clusters de conteneurs gcloud créer-automatiquement hello-cluster
La création et la vérification de l'état de votre cluster GKE prennent quelques minutes

-
Une fois la commande terminée, exécutez la commande suivante pour afficher les trois nœuds du cluster :
kubectl obtenir des nœuds
Production:
NOM STATUT RÔLES ÂGE VERSION gke-hello-cluster-default-pool-229c0700-cbtd Ready 92s v1.18.12-gke.1210 gke-hello-cluster-default-pool-229c0700-fc5j Ready  91s v1.18.12-gke.1210 gke-hello-cluster-default-pool-229c0700-n9l7 Ready  92s v1.18.12-gke.1210
 Console
Go to the
Google Kubernetes Enginepage in the Google Cloud console

Go to Google Kubernetes Engine
Click
Create

Choose Standard or Autopilot mode and click
Configure

In the
Namefield, enter the name
hello-cluster

Select a zone or region:
Standardcluster: Under Location type, select Zonaland then select a Compute Engine zone from the Zonedrop-down list, such as
us-west1-a

Autopilotcluster: Select a Compute Engine region from the Regiondrop-down list, such as
us-west1

-
Click
Create. This creates a GKE cluster

Wait for the cluster to be created. When the cluster is ready, a green check mark appears next to the cluster name

## Deploying the sample app to GKE
You are now ready to deploy the Docker image you built to your GKE cluster

Kubernetes represents applications as Pods, which are scalable units holding one or more containers. The Pod is the smallest deployable unit in Kubernetes. Usually, you deploy Pods as a set of replicas that can be scaled and distributed together across your cluster. One way to deploy a set of replicas is through a Kubernetes Deployment

In this section, you create a Kubernetes Deployment to run
hello-app on your
cluster. This Deployment has replicas (Pods). One Deployment Pod contains only
one container: the
hello-app Docker image

You also create a HorizontalPodAutoscaler resource that scales the number
of Pods from 3 to a number between 1 and 5, based on CPU load

 Cloud Shell
Ensure that you are connected to your GKE cluster

gcloud container clusters get-credentials hello-cluster --zone
COMPUTE_ZONE
Create a Kubernetes Deployment for your
hello-appDocker image

kubectl create deployment hello-app --image=
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1
Set the baseline number of Deployment replicas to 3

kubectl scale deployment hello-app --replicas=3
Create a
HorizontalPodAutoscalerresource for your Deployment

kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5
To see the Pods created, run the following command:
kubectl get pods
Output:
NAME READY STATUS RESTARTS AGE hello-app-784d7569bc-hgmpx 1/1 Running 0 10s hello-app-784d7569bc-jfkz5 1/1 Running 0 10s hello-app-784d7569bc-mnrrl 1/1 Running 0 15s
 Console
Go to the
Workloadspage in the Google Cloud console

Click
Deploy

In the
Specify containersection, select Existing container image

In the
Image pathfield, click Select

In the
Select container imagepane, select the
hello-appimage you pushed to Artifact Registry and click
Select

In the
Containersection, click Done, then click Continue

In the
Configurationsection, under Labels, enter
appfor
Keyand
hello-appfor
Value

Under
Configuration YAML, click View YAML. This opens a YAML configuration file representing the two Kubernetes API resources about to be deployed into your cluster: one Deployment, and one
HorizontalPodAutoscalerfor that Deployment

Click
Close, then click Deploy

When the Deployment Pods are ready, the
Deployment detailspage opens

Under
Managed pods, note the three running Pods for the
hello-appDeployment

## Exposing the sample app to the internet
While Pods do have individually-assigned IP addresses, those IPs can only be reached from inside your cluster. Also, GKE Pods are designed to be ephemeral, starting or stopping based on scaling needs. And when a Pod crashes due to an error, GKE automatically redeploys that Pod, assigning a new Pod IP address each time

What this means is that for any Deployment, the set of IP addresses corresponding to the active set of Pods is dynamic. We need a way to 1) group Pods together into one static hostname, and 2) expose a group of Pods outside the cluster, to the internet

Kubernetes Services solve for both of these problems

Services group Pods
into one static IP address, reachable from any Pod inside the cluster

GKE also assigns a DNS hostname
to that static IP. For example,
hello-app.default.svc.cluster.local

The default Service type in GKE is called ClusterIP,
where the Service gets an IP address reachable only from inside the cluster

To expose a Kubernetes Service outside the cluster, create a Service of
type
LoadBalancer

This type of Service spawns an External Load Balancer IP for a set of Pods,
reachable through the internet

In this section, you expose the
hello-app Deployment to the internet using a
Service of type
LoadBalancer

 Cloud Shell
Use the
kubectl exposecommand to generate a Kubernetes Service for the
hello-appdeployment:
kubectl expose deployment hello-app --name=hello-app-service --type=LoadBalancer --port 80 --target-port 8080
Here, the
--portflag specifies the port number configured on the Load Balancer, and the
--target-portflag specifies the port number that the
hello-appcontainer is listening on

Run the following command to get the Service details for
hello-app-service:
kubectl get service
Output:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-app-service 10.3.251.122 203.0.113.0 80:30877/TCP 10s
Copy the
EXTERNAL_IPaddress to the clipboard (for instance:
203.0.113.0)

 Console
Go to the
Workloadspage in the Google Cloud console

Click
hello-app

From the Deployment details page, click
Actions > Expose

In the
Exposedialog, set the Target portto
8080. This is the port the
hello-appcontainer listens on

From the
Service typedrop-down list, select Load balancer

Click
Exposeto create a Kubernetes Service for
hello-app

When the Load Balancer is ready, the
Service detailspage opens

Scroll down to the
External endpointsfield, and copy the IP address

Now that the
hello-app Pods are exposed to the internet through a Kubernetes Service,
you can open a new browser tab, and navigate to the Service IP address you copied
to the clipboard. A
Hello, World! message appears, along with a
Hostname
field. The
Hostname corresponds to one of the three
hello-app Pods serving your
HTTP request to your browser

## Deploying a new version of the sample app
In this section, you upgrade
hello-app to a new version by building and deploying
a new Docker image to your GKE cluster

GKE's rolling update feature
lets you update your Deployments without downtime. During a rolling update, your GKE cluster
incrementally replaces the existing
hello-app Pods with Pods containing the Docker image for the new version

During the update, your load balancer service routes traffic only into available Pods

Return to Cloud Shell, where you have cloned the hello app source code and Dockerfile. Update the function
hello()in the
main.gofile to report the new version
2.0.0

Build and tag a new
hello-appDocker image

docker build -t
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2 

Push the image to Artifact Registry

docker push
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2
Now you're ready to update your
hello-app Kubernetes Deployment to use a new Docker image

 Cloud Shell
Apply a rolling update to the existing
hello-appDeployment with an image update using the
kubectl set imagecommand:
kubectl set image deployment/hello-app hello-app=
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2
Watch the running Pods running the
v1image stop, and new Pods running the
v2image start

watch kubectl get pods
Output:
NAME READY STATUS RESTARTS AGE hello-app-89dc45f48-5bzqp 1/1 Running 0 2m42s hello-app-89dc45f48-scm66 1/1 Running 0 2m40s
In a separate tab, navigate again to the
hello-app-serviceExternal IP. You should now see the
Versionset to
2.0.0

 Console
Go to the
Workloadspage in the Google Cloud console

Click
hello-app

On the

Deployment detailspage, click Actions > Rolling update

In the
Rolling updatedialog, set the Image of hello-appfield to


REGION-docker.pkg.dev/ PROJECT_ID/hello-repo/hello-app:v2
Click
Update

On the
Deployment detailspage, inspect the Active Revisionssection. You should now see two Revisions, 1 and 2. Revision 1 corresponds to the initial Deployment you created earlier. Revision 2 is the rolling update you just started

After a few moments, refresh the page. Under
Managed pods, all of the replicas of
hello-appnow correspond to Revision 2

In a separate tab, navigate again to the Service IP address you copied. The
Versionshould be
2.0.0

## Clean up
To avoid incurring charges to your Google Cloud account for the resources used in this tutorial, either delete the project that contains the resources, or keep the project and delete the individual resources

Delete the Service:This deallocates the Cloud Load Balancer created for your Service:
kubectl delete service hello-app-service
Delete the cluster:This deletes the resources that make up the cluster, such as the compute instances, disks, and network resources:
gcloud container clusters delete hello-cluster --zone
COMPUTE_ZONE Delete your container images:This deletes the Docker images you pushed to Artifact Registry

gcloud artifacts docker images delete REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1 \ --delete-tags --quiet gcloud artifacts docker images delete \ REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2 \ --delete-tags --quiet
## What's next
Learn about Pricing for GKE and use the Pricing Calculator to estimate costs

Read the Load Balancers tutorial, which demonstrates advanced load balancing configurations for web applications

Configure a static IP and domain name for your application

Explore other Kubernetes Engine tutorials

Explore reference architectures, diagrams, tutorials, and best practices about Google Cloud. Take a look at our Cloud Architecture Center

## Try it for yourself
If you're new to Google Cloud, create an account to evaluate how GKE performs in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.Try GKE free