Déployer un hello-world PHP sur mon KaaS

Date	juin 2025

Voici un tutoriel détaillé pour déployer votre application PHP "Hello World" sur votre cluster KaaS (Kubernetes As A Service) Ziosting, en utilisant Docker Hub et en tenant compte de l'architecture x86 des nœuds sur votre cluster KaaS Ziosting.

CAS 1 : Déployer une Application PHP "Hello World" sur mon cluster KaaS Ziosting et y accéder via `kubectl proxy`

Ce tutoriel vous guidera pas à pas pour empaqueter une simple application PHP dans une image Docker, la pousser sur Docker Hub, puis la déployer sur votre cluster Kubernetes. Vous pourrez y accéder depuis votre poste de travail en local grâce à l'outil kubectl proxy

🎯 Objectifs

Créer une application PHP simple.
Construire une image Docker de l'application, compatible avec l'architecture x86.
Pousser l'image sur Docker Hub.
Déployer l'application sur un cluster Kubernetes.
Vérifier le bon fonctionnement et accéder aux logs.

⚙️ Pré-requis

Avant de commencer, assurez-vous d'avoir les éléments suivants installés et configurés sur votre machine :

Docker Desktop : Nécessaire pour construire et gérer les images Docker.
- Téléchargement : https://www.docker.com/products/docker-desktop/
- Installez-le en suivant les instructions pour le système d'exploitation de votre ordinateur.
kubectl : L'outil en ligne de commande pour interagir avec les clusters Kubernetes.
- Installez-le en suivant les instructions pour le système d'exploitation de votre ordinateur : https://kubernetes.io/fr/docs/tasks/tools/install-kubectl/
- Vérification : kubectl version --client
Accès au cluster Kubernetes :
- Votre fichier kubeconfig doit être présent à l'emplacement /monDossier/monKubeconfig.yaml. (Cette documentation vous guidera)
- Nous utiliserons ce chemin pour configurer kubectl.
Un éditeur de texte : Pour créer les fichiers de code et de configuration (VS Code, Sublime Text, etc.).

Étape 1 : Préparer l'application PHP "Hello World"

Commençons par créer notre application PHP très simple.

Créez un nouveau répertoire pour votre projet. Par exemple, php-hello-world.
```
mkdir php-hello-world
cd php-hello-world
```

Dans ce répertoire, créez un fichier nommé index.php et ajoutez le contenu suivant :

<?php
echo "<h1>Hello World from Kubernetes!</h1>";
echo "<p>Ceci est un test de déploiement d'application PHP.</p>";
echo "<p>Date et heure actuelles : " . date('Y-m-d H:i:s') . "</p>";
?>

Étape 2 : Créer le Dockerfile

Le Dockerfile est un ensemble d'instructions pour Docker afin de construire l'image de votre application. Nous devons spécifier l'architecture linux/amd64 car vos nœuds Kubernetes sont en x86 (AMD64), même si vous construisez depuis un Mac (qui peut être ARM, comme les puces M1/M2).

Dans le même répertoire php-hello-world, créez un fichier nommé Dockerfile (sans extension) et ajoutez le contenu suivant :

# Spécifie l'image de base PHP avec Apache.
# IMPORTANT : Nous utilisons --platform=linux/amd64 pour garantir que l'image
# est construite pour l'architecture x86, même si le Mac local est ARM (M1/M2).
FROM --platform=linux/amd64 php:8.2-apache

# Copie les fichiers de l'application PHP dans le répertoire web par défaut d'Apache.
COPY . /var/www/html/

# Expose le port 80, qui est le port par défaut d'Apache.
EXPOSE 80

Étape 3 : Créer un compte Docker Hub et se connecter

Docker Hub est un registre d'images Docker public. Nous y stockerons notre image pour que Kubernetes puisse la récupérer.

Créer un compte Docker Hub (si vous n'en avez pas) :
- Rendez-vous sur https://hub.docker.com/.
- Cliquez sur le bouton "Sign Up" ou "Get Started".
- Suivez les étapes : entrez une adresse e-mail, choisissez un nom d'utilisateur unique (ce sera votre votre_utilisateur_dockerhub), et définissez un mot de passe.
- Confirmez votre adresse e-mail si nécessaire.
Se connecter à Docker Hub depuis votre terminal :
```
docker login
```
- Le terminal vous demandera votre nom d'utilisateur Docker Hub et votre mot de passe.
- Une fois connecté, vous verrez un message Login Succeeded.

Étape 4 : Construire l'image Docker

Maintenant, construisons l'image Docker de votre application.

Assurez-vous d'être dans le répertoire php-hello-world où se trouvent index.php et Dockerfile.
Assurez-vous que l'application Docker Desktop soit démarrée sur votre ordinateur.
Exécutez la commande suivante pour construire l'image. Remplacez votre_utilisateur_dockerhub par votre nom d'utilisateur Docker Hub.
```
docker build -t votre_utilisateur_dockerhub/php-hello-world:1.0 .
```
- docker build: Commande pour construire une image.
- -t votre_utilisateur_dockerhub/php-hello-world:1.0: Tag (nom et version) de l'image. Il est crucial d'inclure votre nom d'utilisateur Docker Hub pour pouvoir la pousser ensuite.
- .: Indique que le Dockerfile se trouve dans le répertoire courant.
- Le processus de construction peut prendre quelques minutes lors de la première exécution, car Docker doit télécharger l'image de base php:8.2-apache.
Vérifiez que l'image a bien été créée localement :
```
docker images
```
Vous devriez voir php-hello-world dans la liste.

Étape 5 : Pousser l'image sur Docker Hub

Une fois l'image construite localement, poussez-la sur votre dépôt Docker Hub.

Exécutez la commande suivante (remplacez votre_utilisateur_dockerhub) :
```
docker push votre_utilisateur_dockerhub/php-hello-world:1.0
```
- Ce processus télécharge votre image sur Docker Hub.
- Vous pouvez vérifier qu'elle est bien présente en vous connectant à l'interface web de Docker Hub.

Étape 6 : Créer les fichiers de configuration Kubernetes (YAML)

Nous avons besoin d'un Deployment et d'un Service configuré de type ClusterIP (interne au cluster).

Fichier php-hello-world-deployment.yaml : (pensez à changer la valeur votre_utilisateur_dockerhub)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: php-hello-world-deployment
  labels:
    app: php-hello-world
spec:
  replicas: 2
  selector:
    matchLabels:
      app: php-hello-world
  template:
    metadata:
      labels:
        app: php-hello-world
    spec:
      containers:
      - name: php-hello-world
        image: votre_utilisateur_dockerhub/php-hello-world:1.0
        imagePullPolicy: Always
        ports:
        - containerPort: 80

Fichier php-hello-world-service.yaml : Ce service sera de type ClusterIP pour rendre l'application accessible à l'intérieur du cluster.

apiVersion: v1
kind: Service
metadata:
  name: php-hello-world-service
spec:
  selector:
    app: php-hello-world
  ports:
    - protocol: TCP
      port: 80 # Port du service (port exposé par le service)
      targetPort: 80 # Port du conteneur cible
  type: ClusterIP # Service interne au cluster

Étape 7 : Déployer l'application sur Kubernetes

⚠️ L'ordre d'application des fichiers est important : Deployment en premier, puis le Service.

Maintenant, nous allons appliquer ces configurations à votre cluster Kubernetes.

Créez votre namespace puis récupérez son Kubeconfig depuis la console Ziosting (Cette documentation vous guidera)
Configurez kubectl pour utiliser votre kubeconfig :
```
export KUBECONFIG=/monDossier/monKubeconfig.yaml
```
- Cette commande indique à kubectl quel fichier de configuration utiliser pour se connecter au cluster. Vous devrez exécuter cette commande à chaque nouvelle session de terminal, ou l'ajouter à votre fichier .bashrc ou .zshrc pour qu'elle soit persistante.
Déployez le Deployment : Assurez-vous d'être dans le répertoire php-hello-world.
```
kubectl apply -f php-hello-world-deployment.yaml
```
Vous devriez voir deployment.apps/php-hello-world-deployment created.
Déployez le Service :
```
kubectl apply -f php-hello-world-service.yaml
```
Vous devriez voir service/php-hello-world-service created.

Étape 8 : Confirmer le déploiement et voir les logs

Vérifier les déploiements :
```
kubectl get deployments
```
Vous devriez voir php-hello-world-deployment avec 2/2 READY.
Vérifier les Pods :
```
kubectl get pods
```
Vous devriez voir deux pods php-hello-world-deployment-... avec le statut Running. Attendez quelques instants si les pods sont en ContainerCreating ou ImagePullBackOff (cela signifie qu'ils essaient de télécharger l'image).

Vérifier les Services :

kubectl get services

Vous verrez php-hello-world-service mais sa colonne EXTERNAL-IP affichera none car c'est un ClusterIP (service interne).

Exemple de sortie :

NAME                    TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
kubernetes              ClusterIP   10.x.x.1        <none>        443/TCP   Xd
php-hello-world-service ClusterIP   10.x.x.x        <none>        80/TCP    Xs

Voir les logs d'un Pod : Pour voir ce qui se passe à l'intérieur de vos conteneurs, vous pouvez récupérer les logs.
- Obtenez le nom complet d'un de vos pods :
```
kubectl get pods
# Exemple de nom : php-hello-world-deployment-78f9f7d6f5-abcde
```
- Affichez les logs :
```
kubectl logs <nom_complet_du_pod>
```
Vous devriez voir les logs d'Apache et les requêtes HTTP si vous accédez déjà à l'application.

Étape 9 : Accéder à l'application via `kubectl proxy`

Ouvrez un nouveau terminal ou votre navigateur web. Vous pouvez maintenant accéder à votre application via une URL spécifique construite par kubectl proxy.

La structure générale pour accéder à un Service via kubectl proxy est (les valeurs de votre-namespace et nom-du-service sont à adapter) :

http://localhost:8001/api/v1/namespaces/votre-namespace/services/nom-du-service/proxy/

🧹 Nettoyage (Optionnel)

Si vous souhaitez supprimer votre application du cluster :

kubectl delete -f php-hello-world-service.yaml
kubectl delete -f php-hello-world-deployment.yaml

CAS 2 : Déployer une Application PHP "Hello World" sur mon cluster KaaS Ziosting et y accéder depuis n'importe où

Les étapes du tutoriel ci-dessous vous guideront pas à pas pour déployer votre application sur votre cluster Kubernetes et y accéder depuis n'importe où au travers d'Internet.

🎯 Objectifs

Accéder à une application PHP simple au travers d'un nom de domaine et d'une URL dédiée

⚙️ Pré-requis

Pré-requis identiques au cas précédent
Vous aurez besoin en plus d'un Contrôleur Ingress : Chez Ziosting nous configurons par défaut sur votre cluster un Contrôleur Ingress, vous n'avez donc rien à prévoir sur ce point mais il est important que vous le sachiez.

Étape 1 : Créer le fichier de configuration Ingress pour Kubernetes (YAML)

La bonne nouvelle c'est que toutes les étapes précédentes restent totalement valables sans aucun changement requis. Il ne vous manque que le fichier fichier php-hello-world-ingress.yaml.

Cet Ingress gérera le routage externe basé sur le nom d'hôte qui vous concerne. (pensez à changer la valeur nom de domaine de votre application)

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: php-hello-world-ingress
  annotations:
    # Ces annotations peuvent varier en fonction de votre contrôleur Ingress.
    # Pour un contrôleur Nginx, vous pourriez avoir :
    # kubernetes.io/ingress.class: nginx
    # nginx.ingress.kubernetes.io/rewrite-target: /
    # Pour d'autres contrôleurs (cloud-specific), les annotations diffèrent.
    # Demandez à votre administrateur de cluster si des annotations spécifiques sont requises.
spec:
  rules:
  - host: nom de domaine de votre application # VOTRE CNAME (le nom de domaine que vous utiliserez)
    http:
      paths:
      - path: / # Le chemin de l'URL pour lequel cet Ingress est applicable
        pathType: Prefix # Indique que le chemin est un préfixe (ex: / ou /foo)
        backend:
          service:
            name: php-hello-world-service # Le nom du service que l'Ingress doit router vers
            port:
              number: 80 # Le port du service ClusterIP

Étape 2 : Déployer l'ingress sur Kubernetes

⚠️ Si vous avez supprimé les fichiers précédemment sur le cluster, l'ordre d'application des fichiers est important : Deployment en premier, puis le Service, et enfin l'Ingress.

Si vous n'avez rien supprimé, il vous suffira de déployer l'ingress. Nous ajoutons une ressource Ingress pour gérer l'accès externe via le CNAME. L'Ingress utilisera le service déployé précédemment comme cible.

Déployez l'Ingress :
```
kubectl apply -f php-hello-world-ingress.yaml
```
Vous devriez voir ingress.networking.k8s.io/php-hello-world-ingress created.

Vérifier l'Ingress :

kubectl get ingress

Recherchez php-hello-world-ingress. Dans la colonne HOSTS, vous devriez voir l'entrée DNS que vous avez choisi pour votre application

Exemple de sortie :

NAME                    CLASS    HOSTS                          ADDRESS        PORTS   AGE
php-hello-world-ingress <none>   zipaas-dev.mkaas.ziosting.dev			80      Xs

Étape 3 : Accéder à l'application

Avec un Ingress, l'accès se fait directement via le nom de domaine que vous avez spécifié.

Configurez votre DNS : ⚠️ Ceci est une étape CRUCIALE. ⚠️
Assurez-vous que l'entrée DNS que vous avez choisi pour votre application pointe en CNAME sur le Endpoint de votre cluster KaaS visible dans l'onglet "Settings" du KaaS concerné depuis la console Ziosting.

💡 Exemple : le Endpoint du KaaS dans la console Ziosting possède la valeur zipaas-dev.mkaas.ziosting.dev et je veux que mon application réponde sur l'adresse https://hello.ziosting.com.

Dans la zone ziosting.com, je déclare l'entrée DNS suivante : (⚠️ à adapter à vos valeurs)

hello IN CNAME zipaas-dev.mkaas.ziosting.dev.

Ouvrez votre navigateur et accédez directement à : http://entrée_DNS_de_mon_application (à adapter selon votre déclaration DNS, https://hello.ziosting.com dans notre exemple)

Vous devriez voir votre page "Hello World from Kubernetes!" s'afficher.

🧹 Nettoyage (Optionnel)

Si vous souhaitez supprimer votre application et l'Ingress du cluster :

kubectl delete -f php-hello-world-ingress.yaml
kubectl delete -f php-hello-world-service.yaml
kubectl delete -f php-hello-world-deployment.yaml

CAS 1 : Déployer une Application PHP "Hello World" sur mon cluster KaaS Ziosting et y accéder via kubectl proxy​

🎯 Objectifs​

⚙️ Pré-requis​

Étape 1 : Préparer l'application PHP "Hello World"​

Étape 2 : Créer le Dockerfile​

Étape 3 : Créer un compte Docker Hub et se connecter​

Étape 4 : Construire l'image Docker​

Étape 5 : Pousser l'image sur Docker Hub​

Étape 6 : Créer les fichiers de configuration Kubernetes (YAML)​

Étape 7 : Déployer l'application sur Kubernetes​

Étape 8 : Confirmer le déploiement et voir les logs​

Étape 9 : Accéder à l'application via kubectl proxy​

🧹 Nettoyage (Optionnel)​

CAS 2 : Déployer une Application PHP "Hello World" sur mon cluster KaaS Ziosting et y accéder depuis n'importe où​

🎯 Objectifs​

⚙️ Pré-requis​

Étape 1 : Créer le fichier de configuration Ingress pour Kubernetes (YAML)​

Étape 2 : Déployer l'ingress sur Kubernetes​

Étape 3 : Accéder à l'application​

🧹 Nettoyage (Optionnel)​

CAS 1 : Déployer une Application PHP "Hello World" sur mon cluster KaaS Ziosting et y accéder via `kubectl proxy`

🎯 Objectifs

⚙️ Pré-requis

Étape 1 : Préparer l'application PHP "Hello World"

Étape 2 : Créer le Dockerfile

Étape 3 : Créer un compte Docker Hub et se connecter

Étape 4 : Construire l'image Docker

Étape 5 : Pousser l'image sur Docker Hub

Étape 6 : Créer les fichiers de configuration Kubernetes (YAML)

Étape 7 : Déployer l'application sur Kubernetes

Étape 8 : Confirmer le déploiement et voir les logs

Étape 9 : Accéder à l'application via `kubectl proxy`

🧹 Nettoyage (Optionnel)

CAS 2 : Déployer une Application PHP "Hello World" sur mon cluster KaaS Ziosting et y accéder depuis n'importe où

🎯 Objectifs

⚙️ Pré-requis

Étape 1 : Créer le fichier de configuration Ingress pour Kubernetes (YAML)

Étape 2 : Déployer l'ingress sur Kubernetes

Étape 3 : Accéder à l'application

🧹 Nettoyage (Optionnel)