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. Importer l'image dans un registre.
  3. Exécuter le conteneur localement sur votre ordinateur (facultatif).
  4. Créer un cluster de conteneurs.
  5. Déployez 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

Pour activer l'API Kubernetes Engine, procédez comme suit :
  1. Accédez à la page Kubernetes Engine dans Google Cloud Console.
  2. Créer ou sélectionner 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. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

Option A : Utiliser Cloud Shell

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

  1. Accédez à Google Cloud Console.
  2. Cliquez sur le bouton Activer Cloud Shell Bouton d'activation de Cloud Shell en haut de la fenêtre de la console.

    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 installer les outils suivants :

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

É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 Dockerfile pour empaqueter l'application.

  1. Téléchargez le code source hello-app en exécutant les commandes suivantes :

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
    cd kubernetes-engine-samples/hello-app
    
  2. Définissez la variable d'environnement PROJECT_ID sur votre ID de projet Google Cloud (project-id). La variable PROJECT_ID sera utilisée pour associer l'image de conteneur au dépôt Container Registry de votre projet.

    export PROJECT_ID=project-id
    
  3. Créez l'image de conteneur de cette application et attribuez-lui un tag d'importation :

    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 à Container Registry, où l'image sera hébergée. Cette commande n'importe pas l'image.

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

    docker images
    
    Résultat :
    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.

  1. Configurez l'outil de ligne de commande Docker pour qu'il s'authentifie auprès de Container Registry (cette commande n'est à exécuter qu'une seule fois) :

    gcloud auth configure-docker
    
  2. Vous pouvez maintenant importer l'image dans Container Registry 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)

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

    docker run --rm -p 8080:8080 gcr.io/${PROJECT_ID}/hello-app:v1
    
  2. Si vous utilisez Cloud Shell, cliquez sur le bouton Aperçu sur le Web Bouton , 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.

  3. 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 à l'aide du raccourci 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 pour exécuter l'image de 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.

  1. Définissez vos options d'ID de projet et de zone Compute Engine pour l'outil gcloud :

    gcloud config set project $PROJECT_ID
    gcloud config set compute/zone compute-zone
  2. Créez 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.

  3. Une fois la commande terminée, exécutez la commande suivante pour afficher les deux instances de VM du cluster :

    gcloud compute instances list
    
    Résultat :
    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 create deployment 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.

  1. Exécutez la commande suivante pour déployer votre application :

    kubectl create deployment hello-web --image=gcr.io/${PROJECT_ID}/hello-app:v1
    
  2. Pour voir le pod créé par le déploiement, exécutez la commande suivante :

    kubectl get pods
    
    Résultat :
    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

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

L'option --port spécifie le numéro de port configuré sur l'équilibreur de charge et l'option --target-port indique le numéro de port utilisé par le conteneur hello-app.

Une fois que vous avez déterminé l'adresse IP externe de votre application, notez l'adresse EXTERNAL-IP. 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.

  1. Ajoutez deux instances dupliquées à votre déploiement (afin d'en obtenir trois au total) :

    kubectl scale deployment hello-web --replicas=3
    
  2. Affichez les nouvelles instances dupliquées qui s'exécutent sur votre cluster :

    kubectl get deployment hello-web
    
    Résultat :
    NAME        DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
    hello-web   3         3         3            2           1m
  3. Affichez les pods associés à votre déploiement :

    kubectl get pods
    
    Résultat :
    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.

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

    docker build -t gcr.io/${PROJECT_ID}/hello-app:v2 .
    
  2. Transférez l'image vers Container Registry :

    docker push gcr.io/${PROJECT_ID}/hello-app:v2
    
  3. Appliquez une mise à jour progressive au déploiement existant avec une mise à jour d'image :

    kubectl set image deployment/hello-web hello-app=gcr.io/${PROJECT_ID}/hello-app:v2
    
  4. Accédez à nouveau à l'application à l'adresse http://external-ip et observez les modifications que vous avez apportées.

Nettoyer

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 annule l'allocation de l'équilibreur de charge Cloud créé pour le service :

    kubectl delete service hello-web
  2. 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

Étapes suivantes