Créer une application Web à plusieurs niveaux avec Redis et PHP

Autopilot Standard

---

Ce tutoriel explique comment créer une application Web multiniveau à l'aide de Google Kubernetes Engine (GKE).

Dans ce tutoriel, vous allez effectuer les opérations suivantes :

• Configurez une application Web avec une adresse IP externe et un équilibreur de charge.
• Créez un cluster Redis avec un seul maître (leader) et plusieurs instances dupliquées (esclaves).

L'exemple décrit les concepts Kubernetes suivants :

• Configuration déclarative utilisant des fichiers manifeste YAML
• Les déploiements, qui sont des ressources Kubernetes déterminant la configuration d'un ensemble de pods répliqués
• Les services, qui permettent de créer des équilibreurs de charge internes et externes pour un ensemble de pods

Objectifs

Pour déployer et exécuter l'application sur GKE, procédez comme suit :

1. Configurer l'instance maître Redis
2. Configurer deux instances esclaves Redis
3. Configurer l'interface Web
4. Accéder au site Web
5. Augmenter la capacité de l'interface Web à la hausse

Le schéma ci-dessous présente une vue d'ensemble de l'architecture de cluster que vous obtiendrez après avoir réalisé ces objectifs :

Coûts

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

• GKE

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

Cloud Shell est préinstallé avec les logiciels dont vous avez besoin dans ce tutoriel, y compris kubectl et gcloud CLI. Si vous n'utilisez pas Cloud Shell, vous devez installer la gcloud CLI.

1. 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.
2. Install the Google Cloud CLI.

3. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

4. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

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

6. Enable the GKE API:

   gcloud services enable container.googleapis.com

7. Install the Google Cloud CLI.

8. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

9. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

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

11. Enable the GKE API:

    gcloud services enable container.googleapis.com

Préparer l'environnement

Pour configurer votre environnement, procédez comme suit :

1. Définissez les variables d'environnement :

   export PROJECT_ID=PROJECT_ID
   export COMPUTE_LOCATION=COMPUTE_LOCATION
   

   Remplacez les éléments suivants :

   • PROJECT_ID : l'ID de votre projet Google Cloud.
   • COMPUTE_LOCATION : emplacement Compute Engine, tel que us-central1.

2. Clonez le dépôt GitHub.

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

3. Accédez au répertoire de travail :

   cd kubernetes-engine-samples/quickstarts/guestbook/
   

Créer un cluster GKE

Créez un cluster GKE Autopilot ou Standard :

Autopilot

gcloud container clusters create-auto guestbook \
    --location=${COMPUTE_LOCATION} \

Standard

gcloud container clusters create guestbook \
    --location=${COMPUTE_LOCATION} \
    --num-nodes=4

Se connecter au cluster

Configurez kubectl pour communiquer avec le cluster :

gcloud container clusters get-credentials guestbook \
    --location=${COMPUTE_LOCATION}

Configurer l'instance maître Redis

L'application utilise Redis pour stocker ses données. L'application écrit ses données sur une instance maître Redis et lit les données à partir de plusieurs instances esclaves Redis.

1. Le fichier manifeste suivant décrit un déploiement Kubernetes qui exécute un seul pod maître Redis dupliqué:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: redis-leader
     labels:
       app: redis
       role: leader
       tier: backend
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: redis
     template:
       metadata:
         labels:
           app: redis
           role: leader
           tier: backend
       spec:
         containers:
         - name: leader
           image: "docker.io/redis:6.0.5"
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 6379

   Appliquez le fichier manifeste à votre cluster :

   kubectl apply -f redis-leader-deployment.yaml
   

2. Vérifiez que le pod maître Redis est en cours d'exécution :

   kubectl get pods
   

   Le résultat ressemble à ce qui suit :

   NAME                           READY     STATUS    RESTARTS   AGE
   redis-leader-343230949-qfvrq   1/1       Running   0          43s
   

   Plusieurs minutes peuvent être nécessaires pour que STATUS passe de Pending à Running.

Créer le service maître Redis

L'application Web doit communiquer avec l'instance maître Redis pour écrire ses données. Vous pouvez créer un service faisant office de proxy pour le trafic vers le pod maître Redis.

Un service est une abstraction de Kubernetes qui définit un ensemble logique de pods et une règle permettant d'autoriser l'accès à ces pods. Lorsque vous créez un service, vous décrivez les pods à assigner au proxy en fonction des libellés de pods.

1. Le fichier manifeste suivant décrit un service pour l'instance maître Redis:

   apiVersion: v1
   kind: Service
   metadata:
     name: redis-leader
     labels:
       app: redis
       role: leader
       tier: backend
   spec:
     ports:
     - port: 6379
       targetPort: 6379
     selector:
       app: redis
       role: leader
       tier: backend

   Ce fichier manifeste comprend un ensemble de sélecteurs de libellés. Ces libellés correspondent à l'ensemble de libellés déployé à l'étape précédente. Par conséquent, ce service achemine le trafic réseau vers le pod maître Redis créé précédemment.

   La section ports du fichier manifeste déclare un seul mappage de port. Le service achemine le trafic sur le port port: 6379 vers le port targetPort: 6379 des conteneurs correspondant aux libellés selector spécifiés. La propriété containerPort utilisée dans le déploiement doit correspondre à la propriété targetPort utilisée pour acheminer le trafic vers le déploiement.

   Appliquez le fichier manifeste à votre cluster :

   kubectl apply -f redis-leader-service.yaml
   

2. Vérifiez que GKE a créé le service :

   kubectl get service
   

   Le résultat ressemble à ce qui suit :

   NAME           CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   kubernetes     10.51.240.1     <none>        443/TCP    42s
   redis-leader   10.51.242.233   <none>        6379/TCP   12s
   

Configurer des instances esclaves Redis

Bien que le maître Redis soit un pod unique, vous pouvez le rendre hautement disponible afin qu'il réponde à la demande de trafic en ajoutant des instances dupliquées (esclaves) Redis.

1. Le fichier manifeste suivant décrit un déploiement pour les pods esclaves Redis:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: redis-follower
     labels:
       app: redis
       role: follower
       tier: backend
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: redis
     template:
       metadata:
         labels:
           app: redis
           role: follower
           tier: backend
       spec:
         containers:
         - name: follower
           image: us-docker.pkg.dev/google-samples/containers/gke/gb-redis-follower:v2
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 6379

2. Appliquez le fichier manifeste à votre cluster :

   kubectl apply -f redis-follower-deployment.yaml
   

3. Vérifiez que les deux instances répliquées esclaves Redis sont en cours d'exécution :

   kubectl get pods
   

   Le résultat ressemble à ce qui suit :

   NAME                              READY   STATUS    RESTARTS   AGE
   redis-follower-76588f55b7-bnsq6   1/1     Running   0          27s
   redis-follower-76588f55b7-qvtws   1/1     Running   0          27s
   redis-leader-dd446dc55-kl7nl      1/1     Running   0          119s
   

   Plusieurs minutes peuvent être nécessaires pour que STATUS passe de Pending à Running.

Créer le service esclave Redis

L'application Web doit communiquer avec les instances esclaves Redis pour lire les données. Pour rendre les instances esclaves Redis visibles, vous devez configurer un autre service.

1. Le fichier manifeste suivant décrit un service pour les instances esclaves Redis:

   apiVersion: v1
   kind: Service
   metadata:
     name: redis-follower
     labels:
       app: redis
       role: follower
       tier: backend
   spec:
     ports:
       # the port that this service should serve on
     - port: 6379
     selector:
       app: redis
       role: follower
       tier: backend

   Ce fichier manifeste spécifie le service exécuté sur le port 6379. Le champ selector du service correspond aux pods esclaves Redis créés à l'étape précédente.

   Appliquez le fichier manifeste à votre cluster :

   kubectl apply -f redis-follower-service.yaml
   

2. Vérifiez que GKE a créé le service :

   kubectl get service
   

   Le résultat ressemble à ce qui suit :

   NAME           CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   kubernetes     10.51.240.1     <none>        443/TCP    1m
   redis-leader   10.51.242.233   <none>        6379/TCP   49s
   redis-follower 10.51.247.238   <none>        6379/TCP   3s
   

Configurer l'interface Web de l'application

Maintenant que vous disposez d'un espace de stockage Redis pour votre application, démarrez les serveurs Web. Comme les instances esclaves Redis, l'interface est déployée à l'aide d'un déploiement Kubernetes.

L'application Web utilise une interface PHP configurée pour communiquer avec les services maîtres ou esclaves Redis, selon la nature de la requête (lecture ou écriture). Elle expose une interface JSON et propose une expérience utilisateur basée sur jQuery-Ajax.

1. Le fichier manifeste suivant décrit un déploiement pour le serveur Web:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: frontend
   spec:
     replicas: 3
     selector:
       matchLabels:
           app: guestbook
           tier: frontend
     template:
       metadata:
         labels:
           app: guestbook
           tier: frontend
       spec:
         containers:
         - name: php-redis
           image: us-docker.pkg.dev/google-samples/containers/gke/gb-frontend:v5
           env:
           - name: GET_HOSTS_FROM
             value: "dns"
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 80

   Le fichier manifeste spécifie la variable d'environnement GET_HOSTS_FROM=dns. Lorsque vous fournissez la configuration à l'application d'interface Web, celle-ci utilise les noms d'hôte redis-follower et redis-leader pour effectuer une résolution DNS. La résolution DNS recherche les adresses IP des services que vous avez créés aux étapes précédentes. Ce concept s'appelle recherche de services DNS.

   Appliquez le fichier manifeste à votre cluster :

   kubectl apply -f frontend-deployment.yaml
   

2. Vérifiez que les instances dupliquées sont en cours d'exécution :

   kubectl get pods -l app=guestbook -l tier=frontend
   

   Le résultat ressemble à ce qui suit :

   NAME                        READY   STATUS    RESTARTS   AGE
   frontend-7b78458576-8kp8s   1/1     Running   0          37s
   frontend-7b78458576-gg86q   1/1     Running   0          37s
   frontend-7b78458576-hz87g   1/1     Running   0          37s
   

Exposer l'interface sur une adresse IP externe

Avec la configuration actuelle, les services redis-follower et redis-leader que vous avez créés aux étapes précédentes ne sont accessibles que dans le cluster GKE, car le type par défaut d'un service est ClusterIP.

Un service ClusterIP fournit une adresse IP unique pour l'ensemble de pods vers lesquels il pointe. Cette adresse IP est accessible uniquement au sein du cluster.

Pour rendre le service d'interface Web accessible en externe, vous pouvez spécifier type: LoadBalancer ou type: NodePort dans la configuration du service, selon vos besoins.

Le fichier manifeste suivant décrit un service de type LoadBalancer :

apiVersion: v1
kind: Service
metadata:
  name: frontend
  labels:
    app: guestbook
    tier: frontend
spec:
  type: LoadBalancer
  ports:
    # the port that this service should serve on
  - port: 80
  selector:
    app: guestbook
    tier: frontend

La déclaration de port sous la section ports spécifie le port port: 80, et la propriété targetPort n'est pas spécifiée. Lorsque vous omettez la propriété targetPort, la valeur du champ port est indiquée par défaut. Dans ce cas, ce service achemine le trafic externe sur le port 80 vers le port 80 des conteneurs dans le déploiement frontend.

Appliquez le fichier manifeste à votre cluster :

kubectl apply -f frontend-service.yaml

Lors de la création du service frontend, GKE crée un équilibreur de charge et une adresse IP externe. Ces ressources sont susceptibles d'être facturées.

Accéder au site Web de l'application

Pour accéder au site Web de l'application, obtenez l'adresse IP externe du service frontend :

kubectl get service frontend

Le résultat ressemble à ce qui suit :

NAME       CLUSTER-IP      EXTERNAL-IP        PORT(S)        AGE
frontend   10.51.242.136   109.197.92.229     80:32372/TCP   1m

La colonne EXTERNAL-IP peut indiquer <pending> pendant la création de l'équilibreur de charge. Cela peut prendre quelques minutes. Si vous rencontrez des erreurs telles que Does not have minimum availability, attendez quelques minutes. Cette erreur temporaire se produit, car GKE recrée les nœuds pour apporter les modifications.

Copiez l'adresse IP, puis ouvrez la page dans votre navigateur :

Essayez d'ajouter des entrées en saisissant un message, puis en cliquant sur Submit (Envoyer). Le message que vous avez saisi s'affiche dans l'interface. Ce message indique que les données ont bien été ajoutées à Redis via les services que vous avez créés.

Augmenter la capacité de l'interface Web à la hausse

Supposons que votre application fonctionne depuis un certain temps et qu'elle voit sa cote de popularité soudainement grimper en flèche. Vous décidez alors qu'il serait judicieux d'ajouter davantage de serveurs Web à votre interface. Pour ce faire, vous pouvez augmenter le nombre de pods.

1. Augmentez le nombre de pods frontend :

   kubectl scale deployment frontend --replicas=5
   

   Le résultat ressemble à ce qui suit :

   deployment.extensions/frontend scaled
   

2. Vérifiez le nombre d'instances dupliquées en cours d'exécution :

   kubectl get pods
   

   Le résultat ressemble à ce qui suit :

   NAME                             READY     STATUS    RESTARTS   AGE
   frontend-88237173-3s3sc          1/1       Running   0          1s
   frontend-88237173-twgvn          1/1       Running   0          1s
   frontend-88237173-5p257          1/1       Running   0          23m
   frontend-88237173-84036          1/1       Running   0          23m
   frontend-88237173-j3rvr          1/1       Running   0          23m
   redis-leader-343230949-qfvrq     1/1       Running   0          54m
   redis-follower-132015689-dp23k   1/1       Running   0          37m
   redis-follower-132015689-xq9v0   1/1       Running   0          37m
   

   Vous pouvez réduire le nombre de pods frontend à l'aide de la même commande, en remplaçant 5 par 1.

Effectuer un nettoyage

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.

Supprimer le projet

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Supprimer les ressources individuelles

Si vous avez utilisé un projet existant et que vous ne souhaitez pas le supprimer, supprimez les ressources individuelles.

1. Supprimez le service frontend :

   kubectl delete service frontend
   

2. Supprimez le cluster GKE :

   gcloud container clusters delete guestbook
   

Étapes suivantes

• Apprenez à configurer l'autoscaling de pods horizontaux.
• Découvrez comment déployer WordPress dans GKE avec Persistent Disk et Cloud SQL.
• Découvrez comment configurer des noms de domaine avec des adresses IP statiques.
• Découvrez d'autres tutoriels Kubernetes Engine.