TOC

Comment déployer une application PHP avec Kubernetes sur Ubuntu 16.04

L’auteur a sélectionné le Open Internet / Free Speech pour recevoir un don dans le cadre du https://do.co/w4do-cta [ Ecrire pour DOnations] programme.

introduction

Kubernetes est un système d’orchestration de conteneur open source. Il vous permet de créer, mettre à jour et mettre à l’échelle des conteneurs sans vous soucier des temps d’arrêt.

Pour exécuter une application PHP, Nginx agit en tant que proxy pour PHP-FPM. La conteneurisation de cette configuration dans un seul conteneur peut être un processus fastidieux, mais Kubernetes vous aidera à gérer les deux services dans des conteneurs distincts. Utiliser Kubernetes vous permettra de garder vos conteneurs réutilisables et permutables, et vous ne devrez pas reconstruire l’image de votre conteneur à chaque nouvelle version de Nginx ou PHP.

Dans ce tutoriel, vous allez déployer une application PHP 7 sur un cluster Kubernetes avec Nginx et PHP-FPM s’exécutant dans des conteneurs distincts. Vous apprendrez également à conserver vos fichiers de configuration et le code de l’application en dehors de l’image du conteneur en utilisant le système DigitalOcean. Cette approche vous permettra de réutiliser l’image Nginx pour toute application nécessitant un serveur Web / proxy en transmettant un volume de configuration plutôt que de reconstruire l’image.

Conditions préalables

Étape 1 - Création des services PHP-FPM et Nginx

Dans cette étape, vous allez créer les services PHP-FPM et Nginx. Un service permet d’accéder à un ensemble de pods à partir du cluster. Les services d’un cluster peuvent communiquer directement par leur nom, sans avoir besoin d’adresses IP. Le service PHP-FPM autorisera l’accès aux pods PHP-FPM, alors que le service Nginx autorisera l’accès aux pods Nginx.

Étant donné que les pods Nginx utiliseront les pods PHP-FPM par proxy, vous devrez indiquer au service comment les rechercher. Au lieu d’utiliser des adresses IP, vous tirerez parti de la découverte de service automatique de Kubernetes pour utiliser des noms lisibles par l’homme pour acheminer les demandes au service approprié.

Pour créer le service, vous allez créer un fichier de définition d’objet. Chaque définition d’objet Kubernetes est un fichier YAML qui contient au moins les éléments suivants:

  • + apiVersion +: La version de l’API Kubernetes à laquelle la définition appartient.

  • + kind +: L’objet Kubernetes que ce fichier représente. Par exemple, un + pod ou` + service`.

  • + metadata +: Ceci contient le + nom + de l’objet ainsi que tous les + labels + que vous souhaitez éventuellement lui appliquer.

  • + spec +: contient une configuration spécifique en fonction du type d’objet que vous créez, tel que l’image du conteneur ou les ports sur lesquels le conteneur sera accessible.

Tout d’abord, vous allez créer un répertoire contenant vos définitions d’objet Kubernetes.

SSH sur votre * nœud maître * et créez le répertoire + définitions + qui contiendra vos définitions d’objet Kubernetes.

mkdir definitions

Accédez au répertoire + definitions + nouvellement créé:

cd definitions

Créez votre service PHP-FPM en créant un fichier + php_service.yaml +:

nano php_service.yaml

Définissez + kind + en tant que + Service + pour spécifier que cet objet est un service:

php_service.yaml

...
apiVersion: v1
kind: Service

Nommez le service + php + car il donnera accès à PHP-FPM:

php_service.yaml

...
metadata:
 name: php

Vous regrouperez logiquement différents objets avec des étiquettes. Dans ce didacticiel, vous utiliserez des étiquettes pour regrouper les objets en «niveaux», tels que frontend ou backend. Les pods PHP fonctionneront derrière ce service, vous devrez donc le qualifier de tier tier: backend +.

php_service.yaml

...
 labels:
   tier: backend

Un service détermine à quels pods accéder en utilisant les labels + selector +. Un pod correspondant à ces étiquettes sera traité, que le pod ait été créé avant ou après le service. Vous ajouterez des étiquettes pour vos pods plus tard dans le tutoriel.

Utilisez l’étiquette tier tier: backend + pour affecter le module dans le niveau backend. Vous allez également ajouter le label + app: php + pour spécifier que ce pod utilise PHP. Ajoutez ces deux étiquettes après la section + metadata +.

php_service.yaml

...
spec:
 selector:
   app: php
   tier: backend

Ensuite, spécifiez le port utilisé pour accéder à ce service. Vous utiliserez le port + 9000 + dans ce tutoriel. Ajoutez-le au fichier + php_service.yaml + sous + spec +:

php_service.yaml

...
 ports:
   - protocol: TCP
     port: 9000

Votre fichier + php_service.yaml + complété ressemblera à ceci:

php_service.yaml

apiVersion: v1
kind: Service
metadata:
 name: php
 labels:
   tier: backend
spec:
 selector:
   app: php
   tier: backend
 ports:
 - protocol: TCP
   port: 9000

Appuyez sur les touches + CTRL + o + pour enregistrer le fichier, puis + CTRL + x pour quitter` + nano`.

Maintenant que vous avez créé la définition d’objet pour votre service, vous devez utiliser la commande + kubectl apply + pour l’exécuter, ainsi que l’argument + -f + et spécifier votre fichier + php_service.yaml +.

Créez votre service:

kubectl apply -f php_service.yaml

Cette sortie confirme la création du service:

Outputservice/php created

Vérifiez que votre service est en cours d’exécution:

kubectl get svc

Vous verrez votre service PHP-FPM s’exécuter:

OutputNAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP    10m
php          ClusterIP   10.100.59.238   <none>        9000/TCP   5m

Il existe différents service[ pris en charge par Kubernetes. Votre service + php utilise le type de service par défaut,` + ClusterIP`. Ce type de service attribue une adresse IP interne et rend le service accessible uniquement à partir du cluster.

Maintenant que le service PHP-FPM est prêt, vous allez créer le service Nginx. Créez et ouvrez un nouveau fichier nommé + nginx_service.yaml + avec l’éditeur:

nano nginx_service.yaml

Ce service ciblera les pods Nginx, vous allez donc le nommer + nginx +. Vous allez également ajouter un label tier tier: backend +, comme il se doit dans le palier backend:

nginx_service.yaml

apiVersion: v1
kind: Service
metadata:
 name: nginx
 labels:
   tier: backend

Semblable au service + php +, ciblez les pods avec les étiquettes de sélecteur + app: nginx + et + tier: backend +. Rendre ce service accessible sur le port 80, le port HTTP par défaut.

nginx_service.yaml

...
spec:
 selector:
   app: nginx
   tier: backend
 ports:
 - protocol: TCP
   port: 80

Le service Nginx sera accessible au public sur Internet à partir de l’adresse IP publique de votre Droplet. ++ est disponible sur votre https://cloud.digitalocean.com [Digital Cloud Panel]. Sous + spec.externalIPs +, ajoutez:

nginx_service.yaml

...
spec:
 externalIPs:
 -

Votre fichier + nginx_service.yaml + ressemblera à ceci:

nginx_service.yaml

apiVersion: v1
kind: Service
metadata:
 name: nginx
 labels:
   tier: backend
spec:
 selector:
   app: nginx
   tier: backend
 ports:
 - protocol: TCP
   port: 80
 externalIPs:
 -

Enregistrez et fermez le fichier. Créez le service Nginx:

kubectl apply -f nginx_service.yaml

Vous verrez la sortie suivante lorsque le service est en cours d’exécution:

Outputservice/nginx created

Vous pouvez voir tous les services en cours d’exécution en exécutant:

kubectl get svc

Vous verrez les services PHP-FPM et Nginx répertoriés dans le résultat:

OutputNAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP    13m
nginx        ClusterIP   10.102.160.47    80/TCP     50s
php          ClusterIP   10.100.59.238   <none>        9000/TCP   8m

Veuillez noter que si vous souhaitez supprimer un service, vous pouvez exécuter:

kubectl delete svc/

Maintenant que vous avez créé vos services PHP-FPM et Nginx, vous devrez spécifier où stocker le code de votre application et les fichiers de configuration.

Étape 2 - Installation du plug-in de stockage DigitalOcean

Kubernetes fournit différents plug-ins de stockage pouvant créer un espace de stockage pour votre environnement. Dans cette étape, vous installerez le plug-in de stockage DigitalOcean pour créer block storage sur DigitalOcean. . Une fois l’installation terminée, il ajoutera une classe de stockage nommée + do-block-storage que vous utiliserez pour créer votre stockage en bloc.

Vous allez d’abord configurer un objet Kubernetes Secret pour stocker votre jeton d’API DigitalOcean. Les objets secrets sont utilisés pour partager des informations sensibles, telles que des clés et des mots de passe SSH, avec d’autres objets Kubernetes dans le même espace de noms. Les espaces de noms permettent de séparer logiquement vos objets Kubernetes.

Ouvrez un fichier nommé + secret.yaml + avec l’éditeur:

nano secret.yaml

Vous allez nommer votre objet Secret + digitalocean et l’ajouter à l’espace` + kube-system` + namespace. L’espace de noms + kube-system + est l’espace de noms par défaut pour les services internes de Kubernetes et est également utilisé par le plug-in de stockage DigitalOcean pour lancer divers composants.

secret.yaml

apiVersion: v1
kind: Secret
metadata:
 name: digitalocean
 namespace: kube-system

Au lieu d’une clé + spec +, un secret utilise une clé + data ou` + string Data` pour contenir les informations requises. Le paramètre + data + contient les données codées en base64 qui sont automatiquement décodées lors de l’extraction. Le paramètre + stringData + contient des données non codées qui sont automatiquement codées lors de la création ou des mises à jour, et ne les sort pas lors de la récupération de Secrets. Vous utiliserez + stringData + dans ce tutoriel pour plus de commodité.

Ajoutez le + access-token en tant que` + string Data`:

secret.yaml

...
stringData:
 access-token:

Enregistrez et quittez le fichier.

Votre fichier + secret.yaml + ressemblera à ceci:

secret.yaml

apiVersion: v1
kind: Secret
metadata:
 name: digitalocean
 namespace: kube-system
stringData:
 access-token:

Créez le secret:

kubectl apply -f secret.yaml

Vous verrez cette sortie lors de la création de Secret:

Outputsecret/digitalocean created

Vous pouvez afficher le secret avec la commande suivante:

kubectl -n kube-system get secret digitalocean

La sortie ressemblera à ceci:

OutputNAME           TYPE      DATA      AGE
digitalocean   Opaque    1         41s

Le type + Opaque + signifie que ce secret est en lecture seule, ce qui est standard pour + stringData +. Vous pouvez en savoir plus à ce sujet sur la page Secret. Le champ + DATA + indique le nombre d’éléments stockés dans ce secret. Dans ce cas, il indique + 1 + car vous avez une seule clé stockée.

Maintenant que votre secret est en place, installez le plug-in de stockage de bloc DigitalOcean:

kubectl apply -f https://raw.githubusercontent.com/digitalocean/csi-digitalocean/master/deploy/kubernetes/releases/csi-digitalocean-v0.3.0.yaml

Vous verrez une sortie semblable à celle-ci:

Outputstorageclass.storage.k8s.io/do-block-storage created
serviceaccount/csi-attacher created
clusterrole.rbac.authorization.k8s.io/external-attacher-runner created
clusterrolebinding.rbac.authorization.k8s.io/csi-attacher-role created
service/csi-attacher-doplug-in created
statefulset.apps/csi-attacher-doplug-in created
serviceaccount/csi-provisioner created
clusterrole.rbac.authorization.k8s.io/external-provisioner-runner created
clusterrolebinding.rbac.authorization.k8s.io/csi-provisioner-role created
service/csi-provisioner-doplug-in created
statefulset.apps/csi-provisioner-doplug-in created
serviceaccount/csi-doplug-in created
clusterrole.rbac.authorization.k8s.io/csi-doplug-in created
clusterrolebinding.rbac.authorization.k8s.io/csi-doplug-in created
daemonset.apps/csi-doplug-in created

Maintenant que vous avez installé le plug-in de stockage DigitalOcean, vous pouvez créer un stockage en bloc pour contenir votre code d’application et vos fichiers de configuration.

Étape 3 - Création du volume persistant

Avec votre secret en place et le plug-in de stockage de bloc installé, vous êtes maintenant prêt à créer votre Persistent Volume. Un volume persistant, ou PV, est un bloc de stockage d’une taille spécifiée qui vit indépendamment du cycle de vie d’un pod. L’utilisation d’un volume persistant vous permettra de gérer ou de mettre à jour vos pods sans craindre de perdre votre code d’application. On accède à un volume persistant en utilisant un + PersistentVolumeClaim +, ou un PVC, qui monte le PV au chemin requis.

Ouvrez un fichier nommé + code_volume.yaml + avec votre éditeur:

nano code_volume.yaml

Nommez le PVC + code + en ajoutant les paramètres et valeurs suivants à votre fichier:

code_volume.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
 name: code

Le + spec + pour un PVC contient les éléments suivants:

  • + accessModes + qui varient selon le cas d’utilisation. Ceux-ci sont:

  • + ReadWriteOnce + - monte le volume en lecture-écriture par un seul noeud

  • + ReadOnlyMany + - monte le volume en lecture seule par plusieurs noeuds

  • + ReadWriteMany + - monte le volume en lecture-écriture par plusieurs noeuds

  • + resources + - l’espace de stockage dont vous avez besoin

Le stockage de bloc DigitalOcean n’étant monté que sur un seul nœud, vous définissez le + accessModes + sur + ReadWriteOnce +. Ce tutoriel vous guidera dans l’ajout d’une petite quantité de code d’application. 1 Go suffira dans ce cas d’utilisation. Si vous envisagez de stocker une plus grande quantité de code ou de données sur le volume, vous pouvez modifier le paramètre + storage + pour l’adapter à vos besoins. Vous pouvez augmenter la quantité de stockage après la création du volume, mais la réduction du disque n’est pas prise en charge.

code_volume.yaml

...
spec:
 accessModes:
 - ReadWriteOnce
 resources:
   requests:
     storage:

Ensuite, spécifiez la classe de stockage que Kubernetes utilisera pour provisionner les volumes. Vous utiliserez la classe + do-block-storage + créée par le plug-in de stockage en bloc DigitalOcean.

code_volume.yaml

...
 storageClassName: do-block-storage

Votre fichier + code_volume.yaml + ressemblera à ceci:

code_volume.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
 name: code
spec:
 accessModes:
 - ReadWriteOnce
 resources:
   requests:
     storage:
 storageClassName: do-block-storage

Enregistrez et quittez le fichier.

Créez le + code + PersistentVolumeClaim en utilisant + kubectl +:

kubectl apply -f code_volume.yaml

La sortie suivante vous indique que l’objet a été créé avec succès et que vous êtes prêt à monter votre PVC 1 Go en tant que volume.

Outputpersistentvolumeclaim/code created

Pour afficher les volumes persistants (PV) disponibles:

kubectl get pv

Vous verrez votre PV répertorié:

OutputNAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS    CLAIM          STORAGECLASS       REASON    AGE
pvc-ca4df10f-ab8c-11e8-b89d-12331aa95b13   1Gi        RWO            Delete           Bound     default/code   do-block-storage             2m

Les champs ci-dessus donnent un aperçu de votre fichier de configuration, à l’exception de + stratégie de récupération + et + statut +. La ` politique de récupération' définit ce qui est fait avec le PV après la suppression du PVC qui y accède. + Delete + supprime le PV de Kubernetes ainsi que l’infrastructure DigitalOcean. Vous pouvez en savoir plus sur les + politique de récupération + et + Status + à partir de la Kubernetes documentation PV.

Vous avez créé avec succès un volume persistant à l’aide du plug-in de stockage en bloc DigitalOcean. Maintenant que votre volume persistant est prêt, vous allez créer vos pods à l’aide d’un déploiement.

Étape 4 - Création d’un déploiement PHP-FPM

Dans cette étape, vous allez apprendre à utiliser un déploiement pour créer votre pod PHP-FPM. Les déploiements offrent un moyen uniforme de créer, mettre à jour et gérer les modules en utilisant ReplicaSets. Si une mise à jour ne fonctionne pas comme prévu, un déploiement restaurera automatiquement ses pods sur une image précédente.

La clé de déploiement + spec.selector + listera les étiquettes des pods qu’elle gérera. Il utilisera également les touches + template + pour créer les pods requis.

Cette étape présentera également l’utilisation de Init Containers. Init Containers lance une ou plusieurs commandes avant les conteneurs classiques spécifiés sous la clé + template + du pod. Dans ce tutoriel, votre conteneur d’initialisation va récupérer un exemple de fichier + index.php + à partir de https://gist.github.com [GitHub Gist] en utilisant + wget +. Voici le contenu du fichier exemple:

index.php

<?php
echo phpinfo();

Pour créer votre déploiement, ouvrez un nouveau fichier nommé + php_deployment.yaml + avec votre éditeur:

nano php_deployment.yaml

Ce déploiement gérera vos pods PHP-FPM, vous nommerez donc l’objet de déploiement + php +. Les pods appartiennent au niveau backend. Vous devez donc regrouper le déploiement dans ce groupe en utilisant le libellé tier tier: backend +:

php_deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
 name: php
 labels:
   tier: backend

Pour le paramètre + spec + de déploiement, vous spécifierez le nombre de copies de ce pod à créer à l’aide du paramètre + réplicas +. Le nombre de + répliques + variera en fonction de vos besoins et des ressources disponibles. Vous allez créer une réplique dans ce tutoriel:

php_deployment.yaml

...
spec:
 replicas: 1

Ce déploiement gérera les pods correspondant aux libellés + app: php + et + tier: backend +. Sous la touche + sélecteur + ajouter:

php_deployment.yaml

...
 selector:
   matchLabels:
     app: php
     tier: backend

Ensuite, la + spec de déploiement requiert le` + template` pour la définition d’objet de votre pod. Ce modèle définira les spécifications pour créer le pod. Tout d’abord, vous allez ajouter les étiquettes spécifiées pour le + php + service + selectors + et le + matchLabels + de Deployment. Ajoutez + app: php et` + tier: backend` sous + template.metadata.labels:

php_deployment.yaml

...
 template:
   metadata:
     labels:
       app: php
       tier: backend

Un pod peut avoir plusieurs conteneurs et volumes, mais chacun aura besoin d’un nom. Vous pouvez monter des volumes de manière sélective sur un conteneur en spécifiant un chemin de montage pour chaque volume.

Tout d’abord, spécifiez les volumes auxquels vos conteneurs accéderont. Vous avez créé un PVC nommé + code + pour contenir votre code d’application. Nommez donc ce volume + code +. Sous + spec.template.spec.volumes +, ajoutez ce qui suit:

php_deployment.yaml

...
   spec:
     volumes:
     - name: code
       persistentVolumeClaim:
         claimName: code

Ensuite, spécifiez le conteneur que vous voulez exécuter dans ce pod. Vous pouvez trouver diverses images sur the Docker Store, mais dans ce tutoriel, vous utiliserez l’image + php: 7-fpm +.

Sous + spec.template.spec.containers +, ajoutez ce qui suit:

php_deployment.yaml

...
     containers:
     - name: php
       image: php:7-fpm

Ensuite, vous monterez les volumes auxquels le conteneur doit accéder. Ce conteneur exécutera votre code PHP, il devra donc avoir accès au volume + code +. Vous utiliserez également + mountPath + pour spécifier + / code + en tant que point de montage.

Sous + spec.template.spec.containers.volumeMounts +, ajoutez:

php_deployment.yaml

...
       volumeMounts:
       - name: code
         mountPath: /code

Maintenant que vous avez monté votre volume, vous devez obtenir votre code d’application sur le volume. Vous avez peut-être déjà utilisé FTP / SFTP ou cloné le code via une connexion SSH, mais cette étape vous montrera comment copier le code à l’aide d’un conteneur d’initialisation.

En fonction de la complexité de votre processus de configuration, vous pouvez utiliser un seul + initContainer + pour exécuter un script qui construit votre application ou utiliser un + initContainer + par commande. Assurez-vous que les volumes sont montés sur le + initContainer +.

Dans ce tutoriel, vous utiliserez un seul conteneur Init avec + busybox + pour télécharger le code. + busybox + est une petite image contenant l’utilitaire + wget + que vous utiliserez pour accomplir cela.

Sous + spec.template.spec +, ajoutez votre + initContainer + et spécifiez l’image + busybox +:

php_deployment.yaml

...
     initContainers:
     - name: install
       image: busybox

Votre conteneur d’initialisation devra avoir accès au volume + code + afin de pouvoir télécharger le code à cet emplacement. Sous + spec.template.spec.initContainers, montez le volume` + code + sur le chemin + / code + `:

php_deployment.yaml

...
       volumeMounts:
       - name: code
         mountPath: /code

Chaque conteneur d’initialisation doit exécuter une commande + commande +. Votre conteneur d’initialisation utilisera + wget + pour télécharger the code à partir de https://github.com/do-community / php-kubernetes [Github] dans le répertoire de travail + / code +. L’option + -O + donne un nom au fichier téléchargé et vous nommerez ce fichier + index.php +.

Sous le conteneur + install dans + spec.template.spec.initContainers`, ajoutez ces lignes:

php_deployment.yaml

...
       command:
       - wget
       - "-O"
       - "/code/index.php"
       -

Votre fichier + php_deployment.yaml + complété ressemblera à ceci:

php_deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
 name: php
 labels:
   tier: backend
spec:
 replicas: 1
 selector:
   matchLabels:
     app: php
     tier: backend
 template:
   metadata:
     labels:
       app: php
       tier: backend
   spec:
     volumes:
     - name: code
       persistentVolumeClaim:
         claimName: code
     containers:
     - name: php
       image: php:7-fpm
       volumeMounts:
       - name: code
         mountPath: /code
     initContainers:
     - name: install
       image: busybox
       volumeMounts:
       - name: code
         mountPath: /code
       command:
       - wget
       - "-O"
       - "/code/index.php"
       -

Enregistrez le fichier et quittez l’éditeur.

Créez le déploiement PHP-FPM avec + kubectl +:

kubectl apply -f php_deployment.yaml

Vous verrez la sortie suivante lors de la création du déploiement:

Outputdeployment.apps/php created

Pour résumer, ce déploiement commencera par le téléchargement des images spécifiées. Il demandera ensuite le + PersistentVolume + à votre + PersistentVolumeClaim + et exécutera en série votre + initContainers +. Une fois terminé, les conteneurs seront exécutés et monteront les + volumes + sur le point de montage spécifié. Une fois toutes ces étapes terminées, votre pod sera opérationnel.

Vous pouvez afficher votre déploiement en exécutant:

kubectl get deployments

Vous verrez la sortie:

OutputNAME      DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
php       1         1         1            0           19s

Cette sortie peut vous aider à comprendre l’état actuel du déploiement. Un + Deployment + est one des contrôleurs qui maintient un état souhaité. Le + template + que vous avez créé spécifie que l’état + DESIRED + aura 1 + réplicas + du pod nommé + php +. Le champ + CURRENT indique le nombre de réplicas en cours d’exécution. Il doit donc correspondre à l’état` + DESIRED`. Vous pouvez en savoir plus sur les champs restants dans la Kubernetes Deployments documentation.

Vous pouvez afficher les pods lancés par ce déploiement à l’aide de la commande suivante:

kubectl get pods

Le résultat de cette commande varie en fonction du temps écoulé depuis la création du déploiement. Si vous l’exécutez peu de temps après la création, la sortie ressemblera probablement à ceci:

OutputNAME                   READY     STATUS     RESTARTS   AGE
php-86d59fd666-bf8zd   0/1       Init:0/1   0          9s

Les colonnes représentent les informations suivantes:

  • + Ready +: nombre de + réplicas + exécutant ce pod.

  • + Status +: Le statut du pod. + Init + indique que les conteneurs d’initialisation sont en cours d’exécution. Dans cette sortie, 0 des 1 Init Containers sont terminés.

  • + Restarts +: Combien de fois ce processus a-t-il redémarré pour démarrer le pod? Ce nombre augmentera si l’un de vos conteneurs d’initialisation échoue. Le déploiement le redémarrera jusqu’à atteindre l’état souhaité.

En fonction de la complexité de vos scripts de démarrage, le statut peut prendre quelques minutes pour devenir «+ podInitializing +»:

OutputNAME                   READY     STATUS            RESTARTS   AGE
php-86d59fd666-lkwgn   0/1       podInitializing   0          39s

Cela signifie que les conteneurs initiaux sont terminés et que les conteneurs sont en cours d’initialisation. Si vous exécutez la commande alors que tous les conteneurs sont en cours d’exécution, vous verrez que l’état du pod est remplacé par + Running +.

OutputNAME                   READY     STATUS            RESTARTS   AGE
php-86d59fd666-lkwgn   1/1       Running   0          1m

Vous voyez maintenant que votre pod fonctionne correctement. Si votre pod ne démarre pas, vous pouvez déboguer avec les commandes suivantes:

  • Afficher les informations détaillées d’un pod:

kubectl describe pods

  • Afficher les journaux générés par un pod:

kubectl logs

  • Afficher les journaux d’un conteneur spécifique dans un pod:

kubectl logs

Votre code d’application est monté et le service PHP-FPM est maintenant prêt à gérer les connexions. Vous pouvez maintenant créer votre déploiement Nginx.

Étape 5 - Création du déploiement Nginx

Dans cette étape, vous utiliserez un ConfigMap pour configurer Nginx. Un ConfigMap conserve votre configuration dans un format clé-valeur que vous pouvez référencer dans d’autres définitions d’objet Kubernetes. Cette approche vous donnera la possibilité de réutiliser ou d’échanger l’image avec une version différente de Nginx si nécessaire. La mise à jour de ConfigMap répliquera automatiquement les modifications apportées à tout module qui le monte.

Créez un fichier + nginx_configMap.yaml + pour votre ConfigMap avec votre éditeur:

nano nginx_configMap.yaml

Nommez ConfigMap + nginx-config + et regroupez-le dans le micro-service tier tier: backend +:

nginx_configMap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
 name: nginx-config
 labels:
   tier: backend

Ensuite, vous allez ajouter le + data pour ConfigMap. Nommez la clé + config + et ajoutez le contenu de votre fichier de configuration Nginx comme valeur. Vous pouvez utiliser l’exemple de configuration Nginx à l’adresse https://www.digitalocean.com/community/tutorials/how-to-set-up-nginx-server-blocks-virtual-hosts-on-ubuntu-16-04#step- trois-créer-serveur-bloc-fichiers-pour-chaque-domaine [ce tutoriel].

Étant donné que Kubernetes peut acheminer les demandes vers l’hôte approprié pour un service, vous pouvez entrer le nom de votre service PHP-FPM dans le paramètre + fastcgi_pass + à la place de son adresse IP. Ajoutez ce qui suit dans votre fichier + nginx_configMap.yaml +:

nginx_configMap.yaml

...
data:
 config : |
   server {
     index index.php index.html;
     error_log  /var/log/nginx/error.log;
     access_log /var/log/nginx/access.log;
     root ^/code^;

     location / {
         try_files $uri $uri/ /index.php?$query_string;
     }

     location ~ \.php$ {
         try_files $uri =404;
         fastcgi_split_path_info ^(.+\.php)(/.+)$;
         fastcgi_pass ;
         fastcgi_index index.php;
         include fastcgi_params;
         fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
         fastcgi_param PATH_INFO $fastcgi_path_info;
       }
   }

Votre fichier + nginx_configMap.yaml + ressemblera à ceci:

nginx_configMap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
 name: nginx-config
 labels:
   tier: backend
data:
 config : |
   server {
     index index.php index.html;
     error_log  /var/log/nginx/error.log;
     access_log /var/log/nginx/access.log;
     root ;

     location / {
         try_files $uri $uri/ /index.php?$query_string;
     }

     location ~ \.php$ {
         try_files $uri =404;
         fastcgi_split_path_info ^(.+\.php)(/.+)$;
         fastcgi_pass ;
         fastcgi_index index.php;
         include fastcgi_params;
         fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
         fastcgi_param PATH_INFO $fastcgi_path_info;
       }
   }

Enregistrez le fichier et quittez l’éditeur.

Créez le ConfigMap:

kubectl apply -f nginx_configMap.yaml

Vous verrez la sortie suivante:

Outputconfigmap/nginx-config created

Vous avez terminé de créer votre carte ConfigMap et pouvez maintenant créer votre déploiement Nginx.

Commencez par ouvrir un nouveau fichier + nginx_deployment.yaml + dans l’éditeur:

nano nginx_deployment.yaml

Nommez le déploiement + nginx et ajoutez le libellé` + tier: backend`:

nginx_deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
 name: nginx
 labels:
   tier: backend

Spécifiez que vous voulez un + réplicas + dans le déploiement + spec +. Ce déploiement gérera les pods avec les étiquettes + app: nginx et` + tier: backend`. Ajoutez les paramètres et valeurs suivants:

nginx_deployment.yaml

...
spec:
 replicas: 1
 selector:
   matchLabels:
     app: nginx
     tier: backend

Ensuite, ajoutez le pod + template. Vous devez utiliser les mêmes étiquettes que vous avez ajoutées pour le déploiement + selector.matchLabels +. Ajouter ce qui suit:

nginx_deployment.yaml

...
 template:
   metadata:
     labels:
       app: nginx
       tier: backend

Donnez à Nginx l’accès au PVC + code + que vous avez créé précédemment. Sous + spec.template.spec.volumes +, ajoutez:

nginx_deployment.yaml

...
   spec:
     volumes:
     - name: code
       persistentVolumeClaim:
         claimName: code

Les pods peuvent monter un ConfigMap en tant que volume. Spécifier un nom de fichier et une clé créera un fichier avec sa valeur en tant que contenu. Pour utiliser ConfigMap, définissez + chemin + sur le nom du fichier qui contiendra le contenu de la touche + clé +. Vous voulez créer un fichier + site.conf + à partir de la clé + config +. Sous + spec.template.spec.volumes +, ajoutez ce qui suit:

nginx_deployment.yaml

...
     - name: config
       configMap:
         name: nginx-config
         items:
         - key: config
           path: site.conf

Ensuite, vous allez spécifier l’image à partir de laquelle créer votre pod. Ce tutoriel utilisera l’image + nginx: 1.7.9 + pour la stabilité, mais vous pouvez trouver d’autres images Nginx sur the Docker Store. Aussi, rendez Nginx disponible sur le port 80. Sous + spec.template.spec +, ajoutez:

nginx_deployment.yaml

...
     containers:
     - name: nginx
       image:
       ports:
       - containerPort: 80

Nginx et PHP-FPM doivent accéder au fichier par le même chemin. Montez donc le volume + code + sur + + code +:

nginx_deployment.yaml

...
       volumeMounts:
       - name: code
         mountPath: /code

L’image + nginx: 1.7.9 + chargera automatiquement tous les fichiers de configuration situés dans le répertoire + / etc / nginx / conf.d +. Monter le volume + config + dans ce répertoire créera le fichier + / etc / nginx / conf.d / site.conf +. Sous + volumeMounts +, ajoutez ce qui suit:

nginx_deployment.yaml

...
       - name: config
         mountPath: /etc/nginx/conf.d

Votre fichier + nginx_deployment.yaml + ressemblera à ceci:

nginx_deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
 name: nginx
 labels:
   tier: backend
spec:
 replicas: 1
 selector:
   matchLabels:
     app: nginx
     tier: backend
 template:
   metadata:
     labels:
       app: nginx
       tier: backend
   spec:
     volumes:
     - name: code
       persistentVolumeClaim:
         claimName: code
     - name: config
       configMap:
         name: nginx-config
         items:
         - key: config
           path: site.conf
     containers:
     - name: nginx
       image:
       ports:
       - containerPort: 80
       volumeMounts:
       - name: code
         mountPath: /code
       - name: config
         mountPath: /etc/nginx/conf.d

Enregistrez le fichier et quittez l’éditeur.

Créez le déploiement de Nginx:

kubectl apply -f nginx_deployment.yaml

La sortie suivante indique que votre déploiement est maintenant créé:

Outputdeployment.apps/nginx created

Répertoriez vos déploiements avec cette commande:

kubectl get deployments

Vous verrez les déploiements Nginx et PHP-FPM:

OutputNAME      DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
nginx     1         1         1            0           16s
php       1         1         1            1           7m

Répertoriez les pods gérés par les deux déploiements:

kubectl get pods

Vous verrez les pods en cours d’exécution:

OutputNAME                     READY     STATUS    RESTARTS   AGE
nginx-7bf5476b6f-zppml   1/1       Running   0          32s
php-86d59fd666-lkwgn     1/1       Running   0          7m

Maintenant que tous les objets Kubernetes sont actifs, vous pouvez visiter le service Nginx sur votre navigateur.

Lister les services en cours d’exécution:

kubectl get services -o wide

Obtenez l’adresse IP externe de votre service Nginx:

OutputNAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE       SELECTOR
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP    39m       <none>
nginx        ClusterIP   10.102.160.47    80/TCP     27m       app=nginx,tier=backend
php          ClusterIP   10.100.59.238   <none>        9000/TCP   34m       app=php,tier=backend

Sur votre navigateur, visitez votre serveur en tapant + http: // +. Vous verrez le résultat de + phpinfo () + et aurez confirmé que vos services Kubernetes sont opérationnels.

Conclusion

Dans ce guide, vous avez conteneurisé les services PHP-FPM et Nginx afin de pouvoir les gérer indépendamment. Cette approche améliorera non seulement l’évolutivité de votre projet au fur et à mesure de votre développement, mais vous permettra également d’utiliser efficacement les ressources. Vous avez également stocké votre code d’application sur un volume afin de pouvoir facilement mettre à jour vos services à l’avenir.

Related