Kubernetes (également connu sous le nom de k8s) est un système d'orchestration open-source. Il permet aux utilisateurs de déployer, de mettre à l'échelle et de gérer des applications conteneurisées avec un temps d'arrêt minimal. Dans ce tutoriel, vous apprendrez à déployer une PHP application sur un cluster Kubernetes.
Nginx se comporte comme un proxy pour PHP-FPM lors de l'exécution d'une application PHP. Gérer ces deux services dans un seul conteneur est un processus difficile. Kubernetes nous aide à les gérer dans deux conteneurs différents et réduit les tracas. Il permet également aux utilisateurs de réutiliser les conteneurs et de ne pas se soucier de la construction de leur image de conteneur pour chaque nouvelle version de PHP/Nginx.
Vous exécuterez votre application et votre service de proxy dans deux conteneurs séparés. Le tutoriel fournira également des informations sur la façon d'utiliser le stockage local pour créer un Volume Persistant (PV) et une Demande de Volume Persistant (PVC). Vous utiliserez ensuite cette PVC pour conserver vos fichiers de configuration et votre code en dehors des images de conteneur. Après avoir terminé ce tutoriel, vous pourrez réutiliser votre image Nginx pour d'autres applications qui nécessitent un serveur proxy. Vous pouvez y parvenir en transmettant une configuration, au lieu de reconstruire l'image pour cela.
Prérequis
- Une compréhension de base de Kubernetes (k8s) et de ses objets. Reportez-vous à ce guide pour un aperçu détaillé de l'écosystème Kubernetes.
- Un cluster Kubernetes opérationnel sur Ubuntu 18.04. Suivez ce tutoriel pour créer votre cluster Kubernetes à l'aide de kubeadm.
- De plus, vous devez héberger le code de votre application sur une URL publique, par exemple, GitHub.
Étape 1 : Créer les services PHP-FPM et Nginx
Cette étape vous aidera à créer les services PHP-FPM et Nginx. Tout service fournit l'accès à un ensemble de pods au sein d'un cluster. Tous les services présents dans un cluster peuvent communiquer entre eux avec leurs noms, sans adresses IP. Le service PHP-FPM et le service Nginx fourniront un accès aux pods PHP-FPM et Nginx, respectivement.
Vous devrez indiquer au service PHP-FPM comment trouver les pods Nginx car il agira comme un proxy pour les pods PHP-FPM. Pour cela, vous profiterez de la découverte automatique de services de Kubernetes’ et utiliserez des noms lisibles par l'homme pour acheminer la requête vers le service respectif.
Afin de créer un service, vous devrez créer un fichier YAML qui contient la définition de l'objet. Ce fichier YAML comporte au moins les balises suivantes :
apiVersion: La version de l'API Kubernetes à laquelle appartient la définition.kind: Le type d'objet Kubernetes que ce fichier YAML crée. Par exemple : unservice, unjob, ou unpod.metadata: Le nom de l'objet et les différentslabelsque l'utilisateur pourrait vouloir appliquer à cet objet sont définis sous cette balise.spec: Cette balise contient la spécification de votre objet, telle que les variables d'environnement (ENV), l'image de conteneur à utiliser, les ports sur lesquels le service de conteneur sera accessible.
Création du service PHP-FPM
Pour commencer, vous devez créer un répertoire pour conserver vos définitions d'objets Kubernetes. Connectez-vous à votre nœud maître et créez un répertoire nommé “definitions:”
|
1 |
mkdir definitions |
Changez de répertoire pour le répertoire definitions :
|
1 |
cd definitions |
Ensuite, créez votre fichier de service PHP-FPM en tant que fichier php_service.yaml :
|
1 |
nano php_fpm_service.yaml |
Après cela, définissez le apiVersion et le kind dans le fichier php_fpm_service.yaml :
|
1 2 |
apiVersion: v1 kind: Service |
Nommez votre service php ou php-fpm car il fournira un accès à votre application PHP-FPM :
|
1 2 3 |
… Metadata: name: php |
Étiquetez votre service php comme tier: backend car l'application PHP s'exécutera derrière ce service :
|
1 2 3 |
… labels: tier: backend |
Un service utilise les étiquettes de selector pour déterminer les pods auxquels accéder. Tout pod qui correspond à ces étiquettes, quel que soit le moment où il a été créé, est desservi. Vous apprendrez comment ajouter des étiquettes à vos pods plus tard dans ce tutoriel.
Incluez l'étiquette tier: backend qui attribue votre pod au niveau backend, ainsi que l'étiquette app: php-fpm pour indiquer que le pod exécute une application PHP-FPM. Vous devez ajouter ces étiquettes après la section metadata :
|
1 2 3 4 5 |
… spec: selector: app: php-fpm tier: backend |
Ensuite, vous devez déclarer le port pour accéder à ce service php-fpm sous spec. Vous pouvez ajouter le port de votre choix, mais nous utiliserons le port 9000 dans ce tutoriel :
|
1 2 3 4 |
... ports: - protocol: TCP port: 9000 |
Une fois les étapes ci-dessus terminées, votre fichier php_fpm_service.yaml ressemblera à ceci :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
apiVersion: v1 kind: Service metadata: name: php labels: tier: backend spec: selector: app: php tier: backend ports: - protocol: TCP port: 9000 |
Appuyez sur Ctrl + O pour enregistrer le fichier, puis sur Ctrl + X pour quitter nano.
Application de la commande kubectl pour créer le service PHP
Une fois la définition d'objet de votre service créée, exécutez la commande kubectl apply avec l'argument -f en spécifiant votre fichier php_fpm_service.yaml :
|
1 |
kubectl apply -f php_fpm_service.yaml |
La sortie de la commande ci-dessus devrait être :
|
1 |
service/php created |
Exécutez la commande ci-dessous pour vérifier que votre service php-fpm est en cours d'exécution :
|
1 |
$ kubectl get svc |
Vous pourrez voir le service php-fpm opérationnel :
|
1 2 3 |
NAME 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 |
Création du service Nginx
Puisque votre service PHP-FPM est maintenant prêt, il est temps de créer également votre service Nginx. Créez et ouvrez un nouveau fichier YAML pour ce service, nommé nginx_service.yaml dans l'éditeur :
|
1 |
$ nano nginx_service.yaml |
Nommez ce service nginx car il ciblera les pods Nginx. Ce service appartient également au backend, vous devez donc lui ajouter une étiquette tier: backend :
|
1 2 3 4 5 6 |
apiVersion: v1 kind: Service metadata: name: nginx labels: tier: backend |
Comme nous l'avons fait pour le service php-fpm, ajoutez les étiquettes de sélecteur app: nginx et tier: backend pour cibler les pods. Ajoutez le port HTTP par défaut 80 pour accéder à ce service :
|
1 2 3 4 5 6 7 8 |
... spec: selector: app: nginx tier: backend ports: - protocol: TCP port: 80 |
Le service Nginx peut être accessible publiquement sur Internet à partir de l'adresse IP publique. Vous pouvez ajouter l’IP de votre nœud de travail sous la forme your_public_ip. Ajoutez les lignes ci-dessous sous spec.externalIPs:
|
1 2 3 4 5 |
... spec: externalIPs: - your_public_ip |
Votre fichier nginx_service.yaml devrait ressembler à celui ci-dessous une fois que vous aurez terminé toutes les étapes ci-dessus :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
apiVersion: v1 kind: Service metadata: name: nginx labels: tier: backend spec: selector: app: nginx tier: backend ports: - protocol: TCP port: 80 externalIPs: - your_public_ip |
Enregistrez et fermez le fichier après avoir ajouté tous les paramètres requis ci-dessus.
Application de la commande kubectl pour créer le service Nginx
|
1 |
kubectl apply -f nginx_service.yaml |
|
1 |
service/nginx créé |
|
1 |
$ kubectl get svc |
|
1 2 3 4 |
NOM TYPE CLUSTER-IP EXTERNE-IP PORT(S) AGE kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 13m nginx ClusterIP 10.102.160.47 votre_ip_publique 80/TCP 50s php ClusterIP 10.100.59.238 <none> 9000/TCP 8m |
|
1 |
$ kubectl delete svc/nom_du_service |
Étape 2 : Créer un stockage local et un volume persistant
Kubernetes fournit divers plug-ins de stockage qui vous aident à créer un espace de stockage pour votre environnement. Cette étape vous guidera sur la façon de créer un StorageClass local et comment cette classe de stockage peut ensuite être utilisée pour créer un volume persistant.
Création d'un stockage local
Créez un fichier, par exemple storageClass.yaml, dans votre éditeur :
|
1 |
$nano storageClass.yaml |
Ajoutez kind comme "storageClass" et apiVersion comme "storage.k8s.io/v1" comme suit :
|
1 2 |
kind: StorageClass apiVersion: storage.k8s.io/v1 |
Nommez cette StorageClass "my-local-storage" et ajoutez provisioner et volumeBindingMode comme suit :
|
1 2 3 4 5 |
… metadata: name: my-local-storage provisioner: kubernetes.io/no-provisioner volumeBindingMode: Immediate |
Enregistrez et fermez le fichier. Votre fichier storageClass.yaml final devrait ressembler à ceci :
|
1 2 3 4 5 6 |
kind: StorageClass apiVersion: storage.k8s.io/v1 metadata: name: my-local-storage provisioner: kubernetes.io/no-provisioner volumeBindingMode: WaitForFirstConsumer |
Maintenant, créez la StorageClass en exécutant la commande kubectl create, comme ci-dessous :
|
1 |
$ kubectl create -f storageClass.yaml |
Après avoir exécuté la commande ci-dessus, vous devriez obtenir la sortie ci-dessous :
|
1 |
storageclass.storage.k8s.io/my-local-storage créé |
Création d'un volume persistant local
Après avoir créé le stockage local, vous pouvez créer votre volume persistant local. Un volume persistant, également appelé PV, est un stockage en bloc de taille spécifiée qui est indépendant du cycle de vie d'un pod. Un volume persistant local n'est rien d'autre qu'un disque local ou un répertoire disponible sur un nœud de cluster Kubernetes. Ce volume persistant local permet à ses utilisateurs d'accéder au stockage local en utilisant une revendication de volume persistant local (Persistent Volume Claim) d'une manière très simple mais portable. Vous pouvez créer ce volume persistant local en utilisant la classe de stockage que nous venons de créer. Ouvrez un fichier, par exemple persistentVolume.yaml, dans votre éditeur :
|
1 |
$ nano persistentVolume.yaml |
Donnez un nom à ce volume persistant, par exemple "my-local-pv":
|
1 2 3 4 |
apiVersion: v1 kind: PersistentVolume metadata: name: my-local-pv |
Vous pouvez ajouter de la capacité de stockage selon vos besoins lors de la création d'un volume persistant local. Dans ce tutoriel, nous utiliserons 5 Gi pour le stockage :
|
1 2 3 4 |
… spec: capacity: storage: 5Gi |
Ajoutez les accessModes, persistentVolumeReclaimPolicy, et fournissez le même storageClassName que celui utilisé dans storageClass.yaml :
|
1 2 3 4 5 |
… accessModes: - ReadWriteOnce persistentVolumeReclaimPolicy: Retain storageClassName: my-local-storage |
Ajoutez le local.path pour votre Persistent Volume comme ci-dessous :
|
1 2 3 |
… local: path: /mnt/disk/vol |
Après avoir ajouté tous les champs requis, votre fichier persistentVolume.yaml devrait ressembler à ceci :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
apiVersion: v1 kind: PersistentVolume metadata: name: my-local-pv spec: capacity: storage: 5Gi accessModes: - ReadWriteOnce persistentVolumeReclaimPolicy: Retain storageClassName: my-local-storage local: path: /mnt/disk/vol nodeAffinity: required: nodeSelectorTerms: - matchExpressions: - key: kubernetes.io/hostname operator: In values: - worker |
Préparation du volume local
Maintenant, nous devons préparer un volume local sur le nœud “worker” comme nous l'avons ajouté dans le fichier persistentVolume.yaml . Exécutez les commandes ci-dessous sur le nœud que vous avez configuré dans persistentVolume. Dans ce cas, il s'agit du nœud “worker” :
|
1 2 3 |
$ DIRNAME="vol" $ mkdir -p /mnt/disk/$DIRNAME $ chmod 777 /mnt/disk/$DIRNAME |
Exécutez la commande ci-dessous sur le nœud maître où se trouve votre fichier persistentVolume.yaml :
|
1 |
kubectl create -f persistentVolume.yaml |
Vous devriez obtenir la sortie ci-dessous :
|
1 |
persistentvolume/my-local-pv créé |
Puisque vous avez créé avec succès votre stockage local et votre Persistent Volume, vous pouvez maintenant continuer et créer une Persistent Volume Claim pour contenir le code de votre application et vos fichiers de configuration.
Step 3: Create the Persistent Volume
Le code de votre application doit être conservé en toute sécurité pendant que vous gérez ou mettez à jour vos pods. Pour cela, vous utiliserez le Persistent Volume, créé à l'étape précédente, auquel on accède en utilisant une PersistentVolumeClaim, ou PVC. Cette PVC monte le PV au chemin requis.
Ouvrez un fichier, par exemple code_volume.yaml, dans votre éditeur :
|
1 |
$ nano code_volume.yaml |
Nommez votre PVC « code » en ajoutant les paramètres et valeurs ci-dessous à votre fichier :
|
1 2 3 4 |
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: code |
La section spec d'une PVC contient les éléments suivants :
- accessModes : Il existe différentes valeurs possibles pour ce champ, comme suit :
- ReadWriteOnce – Monte le volume pour un seul nœud avec des autorisations de lecture et d'écriture.
- ReadOnlyMany – Monte le volume pour de nombreux nœuds avec une autorisation de lecture seule.
- ReadWriteMany – Monte le volume pour de nombreux nœuds avec des autorisations de lecture et d'écriture.
- resources : Définit l'espace de stockage requis.
Le stockage local étant monté sur un seul nœud, vous devrez définir l'accessMode sur ReadWriteOnce. Dans ce tutoriel, vous n'ajouterez qu'un petit morceau de code d'application, par conséquent 1 Go de stockage sera suffisant ici. Cependant, si vous souhaitez stocker une plus grande quantité de données ou de code, vous pouvez modifier le paramètre de stockage en fonction de vos besoins. Notez qu'une fois le volume créé, vous pourrez augmenter la taille du stockage. Cependant, sa réduction n'est pas prise en charge :
|
1 2 3 4 5 6 7 |
... spec: accessModes: - ReadWriteOnce resources: requests: storage: 1Gi |
Maintenant, déclarez la classe de stockage que le cluster Kubernetes utilisera pour l'allouer aux volumes. Utilisez ici la classe de stockage my-local-storage, créée à l'étape précédente, pour votre storageClassName :
|
1 2 |
... storageClassName: my-local-storage |
Après avoir effectué les étapes ci-dessus, votre code_volume.yaml fichier devrait ressembler à ceci :
|
1 2 3 4 5 6 7 8 9 10 11 |
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: code spec: accessModes: - ReadWriteOnce resources: requests: storage: 1Gi storageClassName: my-local-storage |
Maintenant, enregistrez et fermez le fichier.
Création du PVC
Créez le PVC code en exécutant la commande kubectl apply :
|
1 |
$ kubectl apply -f code_volume.yaml |
Vous devriez obtenir la sortie suivante qui indique que l'objet a été créé avec succès et qu'il est prêt à monter votre PVC de 1 Go en tant que volume :
|
1 |
persistentvolumeclaim/code created |
Vous pouvez exécuter la commande suivante pour vérifier le volume persistant (PV) disponible :
|
1 |
$ kubectl get pv |
La sortie de la commande ci-dessus devrait être la suivante :
|
1 2 |
NAME 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 |
Tous les champs ci-dessus, à l'exception de Reclaim Policy et Status, sont un aperçu de votre fichier de configuration. La Reclaim Policy définit ce qui arrive au PV une fois que le PVC qui y accède est supprimé. La valeur Delete supprime le PV du cluster Kubernetes ainsi que de l'infrastructure de stockage. Vous pouvez vous référer à la documentation sur les PV Kubernetes pour bien comprendre la Reclaim Policy et le Status.
Vous pouvez maintenant créer vos pods à l'aide d'un Deployment, car vous avez créé avec succès votre volume persistant en utilisant le stockage local.
Étape 4 : Créer un Deployment pour votre application PHP-FPM
Cette étape vous aidera à créer votre pod PHP-FPM à l'aide de Deployment. Deployment utilise des ReplicaSets pour fournir un moyen stable de créer, mettre à jour et gérer vos pods. Un Deployment restaure automatiquement ses pods vers une image précédente.
La clé spec.selector dans le Deployment répertorie toutes les étiquettes des pods qu'il gère. Elle utilise également la clé template pour créer les pods requis.
Dans cette étape, nous allons également introduire l'application des Init Containers. Les Init Containers exécutent quelques commandes avant les conteneurs standard spécifiés sous le modèle du pod. Ici, l'Init Container utilisera GitHub Gist (https://gist.github.com/) pour obtenir un exemple de fichier index.php. Le contenu de cet exemple de fichier est :
|
1 2 |
<?php echo phpinfo(); |
Création du Deployment PHP
Ouvrez un nouveau fichier nommé php_deployment.yaml dans votre éditeur pour créer votre Deployment :
|
1 |
$ nano php_deployment.yaml |
Maintenant, nommez l’objet Deployment PHP car ce Deployment gérera vos pods PHP-FPM. Ajoutez l’étiquette tier: backend car le pod appartiendra au niveau backend :
|
1 2 3 4 5 6 |
apiVersion: apps/v1 kind: Deployment metadata: name: php labels: tier: backend |
À l’aide du paramètre replica, spécifiez le nombre de copies de ce pod à créer. Le nombre de réplicas peut varier en fonction de vos besoins et des ressources disponibles. Dans ce tutoriel, vous allez créer un seul réplica de votre pod :
|
1 2 3 4 |
... spec: replicas: 1 |
Ajoutez app: php et tier:backend sous la clé selector qui indique que ce Deployment gérera les pods correspondant à ces deux étiquettes :
|
1 2 3 4 5 |
... selector: matchLabels: app: php tier: backend |
Maintenant, la définition d’objet de votre pod a besoin d’un template sous la spécification de votre Deployment. Ce modèle définit la spécification nécessaire pour créer votre pod. Pour commencer, ajoutez les étiquettes spécifiées pour le sélecteur de service php et les matchLabels du Deployment. Ajoutez ensuite app:php et tier:backend sous template.metadata.labels:
|
1 2 3 4 5 6 7 |
... template: metadata: labels: app: php tier: backend |
Tout d’abord, vous devez spécifier tous les volumes auxquels vos conteneurs accèderont. Nommez ce volume code car vous aviez créé un PVC nommé code pour contenir le code de votre application :
|
1 2 3 4 5 6 |
... spec: volumes: - name: code persistentVolumeClaim: claimName: code |
Ensuite, spécifiez le nom du conteneur ainsi que l’image que vous souhaitez exécuter dans votre pod. Diverses images sont disponibles sur le Docker Store (https://hub.docker.com/explore/), mais dans ce tutoriel, nous utiliserons l’image php:7-fpm :
|
1 2 3 4 |
... containers: - name: php image: php:7-fpm |
Maintenant, montez les volumes auxquels le conteneur doit accéder. Comme ce conteneur exécutera votre code PHP, il aura besoin d’accéder au volume code créé à l’étape précédente. Dans cette étape, vous apprendrez également à copier le code de votre application à l’aide d’un Init Container.
Pour télécharger le code, ce tutoriel vous guidera sur la façon d’utiliser un seul Init Container avec busybox. Busybox est un petit conteneur doté de l’utilitaire wget que vous utiliserez pour y parvenir.
First, add your initContainer under spec.template.spec et spécifiez l’image busybox :
|
1 2 3 4 |
... initContainers: - name: install image: busybox |
Ensuite, afin de télécharger le code dans le volume code, votre Init Container devra y avoir accès. Montez le volume code sur le chemin /code sous spec.template.spec.initContainers:
|
1 2 3 4 |
... volumeMounts: - name: code mountPath: /code |
Chaque Init Container doit exécuter une commande. Cet Init Container utilisera wget pour télécharger le code depuis Github dans le répertoire /code. Vous pouvez passer une option -O pour donner un nom à ce fichier téléchargé, et vous pouvez nommer ce fichier index.php.
De plus, ajoutez les lignes ci-dessous sous le conteneur install dans spec.template.spec.initContainers:
|
1 2 3 4 5 6 |
... command: - wget - "-O" - "/code/index.php" - https://raw.githubusercontent.com/do-community/php-kubernetes/master/index.php |
Une fois toutes ces étapes terminées, votre php_deployment.yaml fichier devrait ressembler à ceci :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
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" - https://raw.githubusercontent.com/do-community/php-kubernetes/master/index.php |
Vous pouvez maintenant enregistrer le fichier et quitter. Ensuite, créez votre déploiement PHP-FPM à l'aide de la commande kubectl apply :
|
1 |
$ kubectl apply -f php_deployment.yaml |
La création réussie du déploiement devrait vous donner la sortie ci-dessous :
|
1 |
deployment.apps/php created |
Ce déploiement commence par télécharger les images spécifiées, puis il demandera le PersistentVolume à votre PersistentVolumeClaim, puis exécutera vos initContainers. Une fois cette étape terminée, les conteneurs s'exécuteront et monteront les volumes sur le point de montage spécifié. Après avoir effectué toutes ces étapes, votre pod sera opérationnel.
Vous pouvez exécuter la commande ci-dessous pour afficher votre déploiement :
|
1 |
$ kubectl get deployments |
Après avoir exécuté la commande ci-dessus, vous devriez obtenir la sortie ci-dessous :
|
1 2 |
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE php 1 1 1 0 19s |
Vous pouvez comprendre l'état actuel du déploiement à l'aide de cette sortie. Un déploiement est un contrôleur qui maintient l'état souhaité. Le champ DESIRED spécifie qu'il possède 1 réplica du pod nommé php. Le champ CURRENT indique combien de réplicas de l'état DESIRED sont actuellement en cours d'exécution. Pour un pod sain, cela devrait correspondre à l'état DESIRED . Vous pouvez en savoir plus sur les champs restants dans la documentation sur les déploiements Kubernetes.
Après cela, pour vérifier l'état de votre pod en cours d'exécution, vous pouvez exécuter la commande ci-dessous :
|
1 |
$ kubectl get pods |
La sortie de cette commande peut varier en fonction du temps écoulé depuis la création de votre déploiement. Si elle est exécutée peu de temps après la création du déploiement, la sortie sera similaire à :
|
1 2 |
NAME READY STATUS RESTARTS AGE php-5d8f6bbf7f-56df2 0/1 Init:0/1 0 9s |
Explication :
Ces colonnes représentent les informations comme ci-dessous :
- Ready : Le nombre de réplicas actuels/souhaités exécutant ce pod.
- Statut : Le statut de votre pod. Init:0/1 indique que les Init Containers sont en cours d'exécution et que 0 sur 1 Init Containers ont fini de s'exécuter.
- Redémarrages : Cela indique le nombre de fois que ce processus a redémarré pour démarrer le pod.
Le changement de statut de votre pod peut prendre quelques minutes pour passer à podInitializing selon la complexité de vos scripts de démarrage :
|
1 2 |
NOM PRÊT STATUT REDÉMARRAGES ÂGE php-5d8f6bbf7f-56df2 0/1 podInitializing 0 39s |
Cela indique que les Init Containers ont été exécutés avec succès et que maintenant, les conteneurs sont en cours d'initialisation :
|
1 2 |
NOM PRÊT STATUT REDÉMARRAGES ÂGE php-5d8f6bbf7f-56df2 1/1 Running 0 4m10s |
Comme vous pouvez le voir maintenant, votre pod est opérationnel. Cependant, au cas où votre pod ne démarrerait pas, vous pouvez exécuter les commandes ci-dessous à des fins de débogage :
1. Pour afficher des informations détaillées sur le pod :
|
1 |
$ kubectl describe pods pod-name |
2. Pour afficher les journaux du pod :
|
1 |
$ kubectl logs pod-name |
3. Pour afficher les journaux d'un conteneur spécifique dans le pod :
|
1 |
$ kubectl logs pod-name container-name |
Félicitations ! Vous avez monté avec succès le code de l'application et le service PHP-FPM est prêt à gérer les connexions. De la même manière, vous pouvez créer votre déploiement Nginx.
Étape 5 : Créez votre déploiement Nginx
Cette étape vous guidera sur la façon de configurer Nginx à l'aide d'un ConfigMap. Un ConfigMap conserve toutes vos configurations requises dans un format clé-valeur qui sera utilisé dans d'autres définitions d'objets Kubernetes. Avec cette approche, vous aurez la flexibilité de réutiliser ou de remplacer l'image Nginx par une version différente, au fur et à mesure des besoins. Vous pouvez mettre à jour le ConfigMap et il répliquera automatiquement ces modifications sur tout pod qui monte ce ConfigMap.
Pour commencer, ouvrez un fichier nginx_configmap.yaml dans votre éditeur :
|
1 |
$ nano nginx_configMap.yaml |
Maintenant, nommez ce ConfigMap nginx-config et ajoutez-le au tier: backend microservice :
|
1 2 3 4 5 6 |
apiVersion: v1 kind: ConfigMap metadata: name: nginx-config labels: tier: backend |
De plus, vous pouvez ajouter les données au ConfigMap. Ajoutez une clé nommée config et ajoutez tout le contenu du fichier de configuration Nginx comme valeur.
Puisqu'il est possible pour Kubernetes de router les requêtes vers les hôtes respectifs pour un service, vous pouvez saisir le nom de votre service PHP-FPM sous le paramètre fastcgi_pass au lieu de son adresse IP. Ajoutez les lignes de code suivantes à votre fichier nginx_configMap.yaml :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
... 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 php:9000; fastcgi_index index.php; include fastcgi_params; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; fastcgi_param PATH_INFO $fastcgi_path_info; } } |
Une fois terminé, votre nginx_configMap.yaml ressemblera à ceci :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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 /code; location / { try_files $uri $uri/ /index.php?$query_string; } location ~ \.php$ { try_files $uri =404; fastcgi_split_path_info ^(.+\.php)(/.+)$; fastcgi_pass php:9000; fastcgi_index index.php; include fastcgi_params; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; fastcgi_param PATH_INFO $fastcgi_path_info; } } |
Vous pouvez maintenant enregistrer et quitter l'éditeur. Exécutez maintenant la kubectl apply commande pour créer le ConfigMap:
|
1 |
$ kubectl apply -f nginx_configMap.yaml |
Après cela, vous devriez voir la sortie suivante sur votre écran :
|
1 |
configmap/nginx-config créé |
Vous avez créé avec succès votre Configmap Nginx. Vous pouvez maintenant créer votre déploiement Nginx.
Création du déploiement Nginx
Pour commencer, vous pouvez créer un nouveau fichier nommé nginx_deployment.yaml dans l'éditeur :
|
1 |
$ nano nginx_deployment.yaml |
Nommez ce déploiement nginx et ajoutez-y l'étiquette tier: backend :
|
1 2 3 4 5 6 7 |
apiVersion: apps/v1 kind: Deployment metadata: name: nginx labels: tier: backend |
Après cela, spécifiez le nombre de réplicas en ajoutant le champ replica dans la spécification du déploiement (spec) et ajoutez-y les étiquettes app: nginx et tier: backend :
|
1 2 3 4 5 6 7 |
... spec: replicas: 1 selector: matchLabels: app: nginx tier: backend |
De même, ajoutez le modèle de pod (template). Assurez-vous d'ajouter les mêmes étiquettes que celles que vous aviez ajoutées dans le selector.matchLabels. Vous pouvez ajouter ce qui suit :
|
1 2 3 4 5 6 |
... template: metadata: labels: app: nginx tier: backend |
Donnez à Nginx l'accès au PVC code créé précédemment en ajoutant les paramètres suivants sous spec.template.spec.volumes:
|
1 2 3 4 5 6 |
... spec: volumes: - name: code persistentVolumeClaim: claimName: code |
|
1 2 3 4 5 6 7 |
... - name: config configMap: name: nginx-config items: - key: config path: site.conf |
Warning: The contents of the key will replace the volume’s mountPath if a file is not specified. In other words, you will lose all the contents in the destination folder if a path is not explicitly specified.
Maintenant, spécifiez le nom, l'image et le port que vous souhaitez utiliser dans votre pod. Ici, nous utiliserons l'image nginx:1.7.9 et le port 80. Ajoutez-les sous spec.template.spec section :
|
1 2 3 4 5 6 |
... containers: - name: nginx image: nginx:1.7.9 ports: - containerPort: 80 |
De plus, montez le volume de code sur /code car Nginx et PHP-FPM devront tous deux accéder au fichier au même chemin :
|
1 2 3 4 |
... volumeMounts: - name: code mountPath: /code |
L'image nginx-1.7.9 charge automatiquement tout fichier de configuration sous le dossier /etc/nginx/conf.d. Maintenant, si nous montons le volume de configuration dans ce répertoire, cela créera /etc/nginx/conf.d/site.conf. Ajoutez ce qui suit sous la section volumeMount :
|
1 2 3 |
... - name: config mountPath: /etc/nginx/conf.d |
Après avoir terminé toutes les étapes ci-dessus, votre fichier nginx_deployment.yaml devrait ressembler à ceci :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
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: nginx:1.7.9 ports: - containerPort: 80 volumeMounts: - name: code mountPath: /code - name: config mountPath: /etc/nginx/conf.d |
Vous pouvez maintenant enregistrer et fermer le fichier, puis créer le Deployment Nginx en exécutant la commande suivante :
|
1 |
$ kubectl apply -f nginx_deployment.yaml |
Une fois la commande exécutée avec succès, vous devriez voir la sortie suivante :
|
1 |
deployment.apps/nginx created |
Vous pouvez lister tous vos Deployments en exécutant les commandes ci-dessous :
|
1 |
$ kubectl get deployments |
Vous devriez maintenant voir les Deployments Nginx et PHP-FPM :
De plus, vous pouvez exécuter la commande suivante pour lister les pods gérés par les deux Deployments listés ci-dessus :
|
1 |
$ kubectl get pods |
Vous verrez que vos deux pods sont opérationnels comme suit :
Puisque tous vos objets Kubernetes sont actifs à ce stade, vous pouvez maintenant accéder au service Nginx sur votre navigateur.
Exécutez la commande suivante pour lister les services :
|
1 |
$ kubectl get services -o wide |
Notez l'IP externe de votre service Nginx :
Maintenant, en utilisant cette IP externe du service Nginx, vous pouvez visiter votre serveur en tapant http://your_public_ip sur votre navigateur. Vous devriez pouvoir voir le résultat de php_info() qui confirme que vos services Kubernetes sont opérationnels.
Conclusion
Dans ce tutoriel, pour gérer vos services PHP-FPM et Nginx de manière indépendante, vous avez conteneurisé les deux services. Ce faisant, non seulement vous améliorerez l'évolutivité de votre projet, mais vous utiliserez également vos ressources de manière efficace. Vous avez également appris à créer un stockage local et un Persistent Volume pour stocker le code de votre application sur un volume et pouvoir facilement mettre à jour vos services à l'avenir. Ce faisant, vous avez amélioré la convivialité et la maintenabilité de votre code.
De plus, jetez un œil à nos autres tutoriels axés sur Docker et Kubernetes que vous pouvez trouver sur notre blog:
- Découvrir Kubernetes
- Comment créer un cluster Kubernetes à l'aide de Kubeadm sur Ubuntu 18.04
- Nettoyer les ressources Docker – Images, conteneurs et volumes
- Déployer Laravel, Nginx et MySQL avec Docker Compose
- Comment installer & exploiter Docker sur Ubuntu dans le cloud public
Bon développement !
Commentaires
Aucun commentaire pour l'instant. Soyez le premier.