Déployer une application Web en conteneur

Dans ce tutoriel, vous découvrirez comment empaqueter une application Web dans une image de conteneur Docker et exécuter cette image sur un cluster Google Kubernetes Engine en tant qu'ensemble d'instances dupliquées à équilibrage de charge pouvant s'adapter aux besoins de vos utilisateurs.

Objectifs

Pour empaqueter et déployer une application sur GKE, vous devez :

  1. empaqueter l'application dans une image Docker ;
  2. exécuter le conteneur localement sur votre ordinateur (facultatif) ;
  3. importer l'image dans un registre ;
  4. créer un cluster de conteneur ;
  5. déployer l'application sur le cluster ;
  6. exposer l'application sur Internet ;
  7. procéder au scaling du déploiement ;
  8. déployer une nouvelle version de l'application.

Avant de commencer

Procédez comme suit pour activer l'API Kubernetes Engine :
  1. Accédez à la page Kubernetes Engine dans la console Google Cloud Platform.
  2. Créez ou sélectionnez un projet.
  3. Patientez le temps de l'activation de l'API et des services associés. Cette opération peut prendre plusieurs minutes.
  4. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

Option A : Utiliser Google Cloud Shell

Vous pouvez suivre ce tutoriel avec Google Cloud Shell, où les outils de ligne de commande gcloud, docker et kubectl utilisés ici sont préinstallés. 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 Google Cloud Shell :

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

    Console Google Cloud Platform

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

    Session Cloud Shell

Option B : Utiliser des outils de ligne de commande localement

Si vous préférez suivre ce tutoriel sur votre poste de travail, vous devez effectuer les opérations suivantes :

  1. Installez le SDK Google Cloud, qui inclut l'outil de ligne de commande gcloud.
  2. À l'aide de l'outil de ligne de commande gcloud, installez l'outil de ligne de commande Kubernetes. kubectl permet de communiquer avec Kubernetes, qui est le système d'orchestration de clusters pour les clusters GKE :

    gcloud components install kubectl
  3. Installez Docker Community Edition (CE) sur votre poste de travail. Vous allez l'utiliser pour créer une image de conteneur pour l'application.

  4. Installez l'outil de contrôle de source Git pour récupérer l'exemple d'application depuis GitHub.

Définir des valeurs par défaut dans l'outil de ligne de commande gcloud

Pour gagner du temps lors de la saisie de vos options d'ID de projet et de zone Compute Engine dans l'outil de ligne de commande gcloud, vous pouvez définir les valeurs par défaut suivantes :
gcloud config set project [PROJECT_ID]
gcloud config set compute/zone us-central1-b

Étape 1 : Construire l'image du conteneur

GKE accepte les images Docker comme format de déploiement de l'application. Pour créer une image Docker, vous devez disposer d’une application et d’un fichier Dockerfile.

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

L'application est empaquetée sous forme d'image Docker à l'aide du fichier Dockerfile, qui contient les instructions de création de l'image. Vous utiliserez ce fichier Dockerfile pour empaqueter l'application.

Pour télécharger le code source de hello-app, exécutez les commandes suivantes :

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

Pour définir la variable d'environnement PROJECT_ID dans votre interface système, récupérez l'ID de projet préconfiguré sur gcloud en exécutant la commande ci-dessous :

export PROJECT_ID="$(gcloud config get-value project -q)"

La valeur de PROJECT_ID constituera le tag de l'image du conteneur qui permettra de la déployer dans un dépôt Container Registry privé.

Pour créer l'image de conteneur de cette application et lui donner un tag d'importation, exécutez la commande suivante :

docker build -t gcr.io/${PROJECT_ID}/hello-app:v1 .

Cette commande indique à Docker qu'il doit créer l'image à l'aide du fichier Dockerfile dans le répertoire actuel et lui attribuer un nom tel que gcr.io/my-project/hello-app:v1. Le préfixe gcr.io fait référence à Google Container Registry, où l'image sera hébergée. Cette commande n'importe pas l'image.

Vous pouvez exécuter la commande docker images pour vérifier que l'image a été correctement créée :

docker images
Sortie :
REPOSITORY                     TAG                 IMAGE ID            CREATED             SIZE
gcr.io/my-project/hello-app    v1                  25cfadb1bf28        10 seconds ago      54 MB

Étape 2 : Importer l'image de conteneur

Vous devez importer l'image de conteneur dans un registre pour que GKE puisse la télécharger et l'exécuter.

Configurez d'abord l'outil de ligne de commande Docker pour l'authentifier auprès du registre de conteneurs Container Registry (vous n'aurez besoin de l'exécuter qu'une seule fois) :

gcloud auth configure-docker

Vous pouvez maintenant importer l'image dans le registre de conteneurs avec l'outil de ligne de commande Docker :

docker push gcr.io/${PROJECT_ID}/hello-app:v1

Étape 3 : Exécuter le conteneur localement (facultatif)

Pour tester l'image de conteneur à l'aide du moteur Docker local, exécutez la commande suivante :

docker run --rm -p 8080:8080 gcr.io/${PROJECT_ID}/hello-app:v1

Si vous êtes sur Cloud Shell, vous pouvez cliquer sur le bouton "Aperçu sur le Web" en haut à droite pour voir l'application s'exécuter dans un onglet du navigateur. Sinon, ouvrez une nouvelle fenêtre de terminal (ou un onglet Cloud Shell) et exécutez la commande ci-dessous pour vérifier que le conteneur fonctionne et répond aux requêtes par "Hello, World !" :

curl http://localhost:8080

Une fois que vous avez obtenu une réponse positive, vous pouvez fermer le conteneur en appuyant sur Ctrl+C dans l'onglet où la commande docker run est exécutée.

Étape 4 : Créer un cluster de conteneurs

Maintenant que l'image de conteneur est stockée dans un registre, vous devez créer un cluster de conteneurs pour exécuter l'image du conteneur. Un cluster 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.

Une fois que vous avez créé un cluster GKE, vous déployez les applications sur le cluster et gérez le cycle de vie des applications à l'aide de Kubernetes.

Exécutez la commande suivante pour créer un cluster à deux nœuds nommé hello-cluster :

gcloud container clusters create hello-cluster --num-nodes=2

La création du cluster peut prendre plusieurs minutes. Une fois la commande terminée, exécutez la commande suivante et consultez les trois instances de VM de calcul du cluster :

gcloud compute instances list
Sortie :
NAME                                          ZONE           MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP     STATUS
gke-hello-cluster-default-pool-07a63240-822n  us-central1-b  n1-standard-1               10.128.0.7   35.192.16.148   RUNNING
gke-hello-cluster-default-pool-07a63240-kbtq  us-central1-b  n1-standard-1               10.128.0.4   35.193.136.140  RUNNING

Étape 5 : Déployer l'application

Pour déployer et gérer des applications sur un cluster GKE, vous devez communiquer avec le système de gestion de clusters Kubernetes. Pour ce faire, vous utiliserez généralement l'outil de ligne de commande kubectl.

Kubernetes représente les applications comme des pods, qui sont des unités représentant un conteneur (ou groupe de conteneurs étroitement couplés). Le pod est la plus petite unité déployable dans Kubernetes. Dans ce tutoriel, chaque pod ne contient que le conteneur hello-app.

La commande kubectl run ci-dessous amène Kubernetes à créer un objet Déploiement nommé hello-web sur votre cluster. Le déploiement gère plusieurs copies de l'application, appelées instances dupliquées, et planifie leur exécution sur les nœuds individuels du cluster. Dans ce cas, le déploiement n'exécute qu'un seul pod de l'application.

Exécutez la commande suivante pour déployer l'application, en écoutant sur le port 8080 :

kubectl run hello-web --image=gcr.io/${PROJECT_ID}/hello-app:v1 --port 8080

Pour voir le pod créé par le déploiement, exécutez la commande suivante :

kubectl get pods
Sortie :
NAME                         READY     STATUS    RESTARTS   AGE
hello-web-4017757401-px7tx   1/1       Running   0          3s

Étape 6 : Exposer l'application sur Internet

Par défaut, les conteneurs que vous exécutez sur GKE ne sont pas accessibles depuis Internet, car ils ne possèdent pas d'adresses IP externes. Vous devez explicitement exposer l'application au trafic Internet. Pour cela, exécutez la commande suivante :

kubectl expose deployment hello-web --type=LoadBalancer --port 80 --target-port 8080

La commande kubectl expose ci-dessus crée une ressource Service, qui offre une compatibilité réseau et IP avec les pods de l'application. GKE crée une adresse IP externe et un équilibreur de charge (susceptible d'être facturé) pour l'application.

L'indicateur --port spécifie le numéro de port configuré sur l'équilibreur de charge et l'indicateur --target-port indique le numéro de port utilisé par le pod créé par la commande kubectl run à l'étape précédente.

Une fois que vous avez déterminé l'adresse IP externe de l'application, copiez-la. Pointez le navigateur sur cette URL (telle que http://203.0.113.0) pour vérifier si l'application est accessible.

Étape 7 : Procéder au scaling de l'application

Vous pouvez ajouter des instances dupliquées supplémentaires à la ressource de déploiement de l'application avec la commande kubectl scale. Pour ajouter deux instances dupliquées supplémentaires au déploiement (afin d'en obtenir trois au total), exécutez la commande suivante :

kubectl scale deployment hello-web --replicas=3

Vous pouvez afficher les nouvelles instances dupliquées en exécutant les commandes suivantes :

kubectl get deployment hello-web
Sortie :
NAME        DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-web   3         3         3            2           1m
kubectl get pods
Sortie :
NAME                         READY     STATUS    RESTARTS   AGE
hello-web-4017757401-ntgdb   1/1       Running   0          9s
hello-web-4017757401-pc4j9   1/1       Running   0          9s
hello-web-4017757401-px7tx   1/1       Running   0          1m

Plusieurs instances de l'application s'exécutent désormais indépendamment les unes des autres et vous pouvez ajuster la capacité de l'application à l'aide de la commande kubectl scale.

L'équilibreur de charge que vous avez configuré à l'étape précédente procédera automatiquement au routage du trafic vers ces nouvelles instances dupliquées.

Étape 8 : Déployer une nouvelle version de l'application

Le mécanisme de mise à jour progressive de GKE garantit que l'application reste active et disponible même lorsque le système remplace les instances de l'ancienne image de conteneur par la nouvelle image sur toutes les instances dupliquées en cours d'exécution.

Vous pouvez créer une image pour la version v2 de l'application en créant le même code source et en lui attribuant le tag v2 (ou bien vous pouvez remplacer la chaîne "Hello, World!" par la chaîne "Hello, GKE!" avant de créer l'image) :

docker build -t gcr.io/${PROJECT_ID}/hello-app:v2 .

Transférer l'image vers Google Container Registry :

docker push gcr.io/${PROJECT_ID}/hello-app:v2

Appliquez maintenant une mise à jour progressive au déploiement existant avec une mise à jour d'image :

kubectl set image deployment/hello-web hello-web=gcr.io/${PROJECT_ID}/hello-app:v2

Accédez à nouveau à l'application à l'adresse http://[EXTERNAL_IP] et observez les modifications que vous avez apportées.

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform :

Une fois ce tutoriel terminé, procédez comme suit pour supprimer les ressources suivantes afin d'éviter que des frais inutiles ne vous soient facturés :

  1. Supprimez le service : cette étape désaffectera l’équilibreur de charge Cloud créé pour la ressource Service :

    kubectl delete service hello-web

  2. Supprimez le cluster de conteneurs : cette étape supprime les ressources qui constituent le cluster de conteneurs, telles que les instances de calcul, les disques et les ressources réseau.

    gcloud container clusters delete hello-cluster

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Tutoriels Kubernetes Engine