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

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

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 :

  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 :

Application Web s&#39;exécutant sur GKE

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.