Créer un livre d'or avec Redis et PHP

Ce tutoriel explique comment créer une application Web multiniveau simple à l'aide de GKE. Le champ d'application du tutoriel est un livre d'or qui permet aux visiteurs de saisir du texte dans un journal et de consulter les dernières entrées consignées.

Ce tutoriel explique comment configurer le service Web du livre d'or sur une adresse IP externe avec un équilibreur de charge et comment exécuter un cluster Redis avec une seule instance maître et plusieurs instances dupliquées (esclaves).

L'exemple met en évidence un certain nombre de concepts GKE importants :

  • 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
  • Services permettant de créer des équilibreurs de charge internes et externes pour un ensemble de pods

Objectifs

Pour déployer et exécuter l'application Livre d'or sur GKE, vous devez réaliser les opérations suivantes :

  1. Configurer l'instance maître Redis
  2. Configurer deux instances esclaves Redis
  3. Configurer l'interface Web du livre d'or
  4. Visiter le site Web du livre d'or
  5. Faire évoluer l'interface Web du livre d'or

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é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 Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

Installez les outils de ligne de commande suivants utilisés dans ce tutoriel :

  • gcloud permet de créer et de supprimer des clusters Kubernetes Engine. gcloud est inclus dans le SDK Google Cloud.
  • kubectl permet de gérer Kubernetes, le système d'orchestration de clusters utilisé par Kubernetes Engine. Vous pouvez installer kubectl avec gcloud :
    gcloud components install kubectl

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

Pour gagner du temps lors de la saisie de votre ID de projet et des options de la 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 compute-zone

Créer un cluster GKE

La première étape consiste à créer un cluster GKE sur lequel vous allez exécuter l'application Livre d'or et le service Redis.

Créez un cluster GKE nommé guestbook :

gcloud container clusters create guestbook --num-nodes=4

Vous pouvez répertorier les clusters exécutés dans votre projet à l'aide des commandes suivantes :

gcloud container clusters list
gcloud container clusters describe guestbook

Étape 1 : Configurer l'instance maître Redis

L'application Livre d'or utilise Redis pour stocker ses données. Elle les écrit sur une instance maître Redis et les lit depuis plusieurs instances esclaves Redis. La première étape consiste à déployer une instance maître Redis.

Tout d'abord, clonez les exemples de fichiers manifestes.

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/guestbook
git checkout abbb383

Utilisez le fichier manifeste nommé redis-leader-deployment pour déployer l'instance maître Redis. Ce fichier manifeste spécifie 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

Exécutez la commande suivante pour déployer l'instance maître Redis :

kubectl apply -f redis-leader-deployment.yaml

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

kubectl get pods
Résultat :
NAME                           READY     STATUS    RESTARTS   AGE
redis-leader-343230949-qfvrq   1/1       Running   0          43s

Exécutez la commande suivante pour examiner les journaux du pod maître Redis :

kubectl logs deployment/redis-leader

Résultat :

1:M 24 Jun 2020 14:48:20.917 * Ready to accept connections

Créer le service maître Redis

L'application Livre d'or doit communiquer avec l'instance maître Redis pour écrire ses données. Vous devez 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'y accéder. Il s'agit en réalité d'un équilibreur de charge nommé que les proxys redirigent vers un ou plusieurs pods. Lorsque vous configurez un service, vous lui indiquez les pods que les proxys doivent rediriger selon les libellés attribués aux pods en question.

Examinez le fichier manifeste redis-leader-service.yaml décrivant une ressource de 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 crée un service nommé redis-leader avec 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éé à l'étape 1.

La section ports du fichier manifeste déclare un seul mappage de port. Dans ce cas, 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. Notez que la propriété containerPort utilisée dans le déploiement doit correspondre à la propriété targetPort pour acheminer le trafic vers le déploiement.

Démarrez le service de l'instance maître Redis en exécutant la commande suivante :

kubectl apply -f redis-leader-service.yaml

Vérifiez que le service est créé à l'aide de la commande suivante :

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

Étape 2 : Configurer les 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.

Examinez le fichier manifeste redis-follower-deployment.yaml décrivant un déploiement pour les pods 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: gcr.io/google_samples/gb-redis-follower:v2
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
        ports:
        - containerPort: 6379

Pour créer le déploiement d'une instance esclave Redis, exécutez la commande suivante :

kubectl apply -f redis-follower-deployment.yaml

Vérifiez que les deux instances dupliquées Redis sont exécutées en interrogeant la liste des pods :

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

Obtenez les journaux de pod de l'une des instances esclaves Redis.

kubectl logs deployment/redis-follower
Résultat :
1:M 24 Jun 2020 14:50:43.617 * Background saving terminated with success
1:M 24 Jun 2020 14:50:43.617 * Synchronization with replica 10.12.3.4:6379 succeeded

Créer le service esclave Redis

L'application Livre d'or 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.

Le fichier redis-follower-service.yaml définit la configuration du 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 définit un service nommé redis-follower qui s'exécute sur le port 6379. Notez que le champ selector du service correspond aux pods esclaves Redis créés à l'étape précédente.

Créez le service redis-follower en exécutant la commande suivante :

kubectl apply -f redis-follower-service.yaml

Vérifiez que le service est créé :

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

Étape 3 : Configurer l'interface Web du livre d'or

Maintenant que le stockage Redis de votre livre d'or est opérationnel, démarrez les serveurs Web pour ce dernier. Comme les instances esclaves Redis, l'interface sera déployée à l'aide d'un déploiement Kubernetes.

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

Affichez le fichier manifeste frontend-deployment.yaml décrivant le déploiement pour le serveur Web du livre d'or :

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: gcr.io/google_samples/gb-frontend:v5
        env:
        - name: GET_HOSTS_FROM
          value: "dns"
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
        ports:
        - containerPort: 80

Pour créer le déploiement de l'interface Web du livre d'or, exécutez la commande suivante :

kubectl apply -f frontend-deployment.yaml

Vérifiez que les trois instances dupliquées sont en cours d'exécution en interrogeant la liste des libellés qui identifient l'interface Web :

kubectl get pods -l app=guestbook -l tier=frontend
Résultat :
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

Le fichier manifeste ci-dessus spécifie la variable d'environnement GET_HOSTS_FROM=dns. Lorsque l'application d'interface Web de livre d'or fournit cette configuration, elle utilise les noms d'hôte redis-follower et redis-leader et effectue une recherche DNS pour trouver les adresses IP des services respectifs que vous avez créés aux étapes précédentes. Ce concept s'appelle recherche de services DNS.

Exposer l'interface sur une adresse IP externe

Les services redis-follower et redis-leader que vous avez créés lors des étapes précédentes ne sont accessibles que dans le cluster GKE, car le type par défaut d'un service est ClusterIP. ClusterIP fournit une seule adresse IP pour l'ensemble de pods vers lesquels pointe le service. Cette adresse IP est accessible uniquement au sein du cluster.

Toutefois, le service d'interface Web du livre d'or doit être visible par des utilisateurs externes. Autrement dit, un client doit pouvoir demander le service en dehors du cluster GKE. Pour ce faire, vous pouvez spécifier type: LoadBalancer ou type: NodePort dans la configuration du service, en fonction de vos besoins. Dans cet exemple, vous utiliserez type: LoadBalancer. Le fichier manifeste frontend-service.yaml spécifiant cette configuration se présente comme suit :

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

Lors de la création du service frontend, GKE crée un équilibreur de charge et une adresse IP externe. Notez que ces ressources sont susceptibles d'être facturées. 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.

Pour créer le service, exécutez la commande suivante :

kubectl apply -f frontend-service.yaml

Étape 4 : Accéder au site Web du livre d'or

Pour accéder au service Livre d'or, vous devez trouver l'adresse IP externe du service que vous venez de configurer en exécutant la commande suivante :

kubectl get service frontend
Résultat :
NAME       CLUSTER-IP      EXTERNAL-IP        PORT(S)        AGE
frontend   10.51.242.136   109.197.92.229     80:32372/TCP   1m

Copiez l'adresse IP dans la colonne "EXTERNAL-IP", puis chargez la page dans le navigateur :

Livre d'or s'exécutant sur GKE

Essayez d'ajouter des entrées au livre d'or en saisissant un message, puis en cliquant sur Envoyer. Le message que vous avez saisi devrait s'afficher dans l'interface. Cela indique que les données ont bien été ajoutées à Redis via les services que vous avez créés précédemment.

Étape 5 : Faire évoluer l'interface Web

Supposons que votre application Livre d'or 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. Vous pouvez réaliser facilement cette opération, car vos serveurs sont définis comme un service utilisant un contrôleur de déploiement.

Faites passer le nombre de vos pods frontend à cinq en exécutant la commande suivante :

kubectl scale deployment frontend --replicas=5

Résultat :

deployment.extensions/frontend scaled

La configuration pour le déploiement est mise à jour pour spécifier qu'à présent, cinq instances dupliquées doivent être en cours d'exécution. Le déploiement ajuste le nombre de pods qu'il exécute pour correspondre cette configuration. Pour vérifier que la modification a bien été appliquée, exécutez la commande suivante :

kubectl get pods
Résultat :
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 d'interface à l'aide de la même commande.

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud Platform, procédez comme suit :

Étape 6 : Effectuer un nettoyage

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ésaffecte l'équilibreur de charge cloud créé pour le service frontend :

    kubectl delete service frontend

  2. Attendez que l'équilibreur de charge provisionné pour le service frontend soit supprimé. L'équilibreur de charge est supprimé de manière asynchrone en arrière-plan lorsque vous exécutez kubectl delete. Patientez le temps que l'équilibreur de charge soit supprimé en surveillant le résultat de la commande suivante :

    gcloud compute forwarding-rules list

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

    gcloud container clusters delete guestbook

Étapes suivantes