Internet
    │
    ▼
HAProxy dédié (192.168.0.254)
    │
    ├─── :6443   ──→ xsel-master-01 (192.168.0.1)
    │                xsel-master-02 (192.168.0.2)
    │
    ├─── :80/443 ──→ xsel-devnode-01 (192.168.1.1:30080/30443)
    │                xsel-devnode-02 (192.168.1.2:30080/30443)
    │                xsel-devnode-03 (192.168.1.3:30080/30443)
    │                    │
    │                    └─→ NGINX Ingress → Pods applicatifs
    │
    └─── :3306   ──→ MySQL via ProxySQL (NodePort)
         :5432   ──→ PostgreSQL via PGBouncer (NodePort)
         :5433   ──→ PostgreSQL direct (NodePort)

Internet
    │
    ▼
Serveur HAProxy dédié
IP publique : <PUBLIC_IP_HAPROXY>
IP WG100    : 192.168.0.254
    │
    ├── :6443/TCP   → API Kubernetes          (192.168.0.1/2)
    ├── :80/TCP     → NGINX Ingress HTTP      (192.168.1.1/2/3:30080)
    ├── :443/TCP    → NGINX Ingress HTTPS     (192.168.1.1/2/3:30443)
    ├── :3306/TCP   → MySQL ProxySQL          (192.168.1.1/2/3:NodePort)
    ├── :5432/TCP   → PostgreSQL PGBouncer    (192.168.1.1/2/3:NodePort)
    └── :5433/TCP   → PostgreSQL direct       (192.168.1.1/2/3:NodePort)

# Créer la structure
# Créer les répertoires de configuration et de logs HAProxy
mkdir -p /opt/xsel-haproxy/config
mkdir -p /opt/xsel-haproxy/logs

# Arborescence finale
# /opt/xsel-haproxy/
#   ├── docker-compose.yml
#   ├── config/
#   │   └── haproxy.cfg
#   └── logs/

# Ouvrir tous les ports nécessaires au LB
firewall-cmd --add-port=80/tcp --permanent    # HTTP applicatif
firewall-cmd --add-port=443/tcp --permanent   # HTTPS applicatif
firewall-cmd --add-port=6443/tcp --permanent  # API Kubernetes
firewall-cmd --add-port=51821/udp --permanent # WireGuard VPN (futur)
firewall-cmd --add-port=3306/tcp --permanent  # MySQL externe
firewall-cmd --add-port=5432/tcp --permanent  # PostgreSQL PGBouncer
firewall-cmd --add-port=5433/tcp --permanent  # PostgreSQL direct
firewall-cmd --add-port=8404/tcp --permanent  # Stats HAProxy
# Appliquer toutes les règles de firewall en persistance
firewall-cmd --reload

# Vérifier
# Vérifier que tous les ports sont bien ouverts
firewall-cmd --list-ports

80/tcp 443/tcp 6443/tcp 51821/udp 3306/tcp 5432/tcp 5433/tcp 8404/tcp

# Ajouter wg100 à la zone trusted
# Ajouter l'interface WireGuard WG100 à la zone trusted pour autoriser le trafic Kubernetes
firewall-cmd --zone=trusted --add-interface=wg100 --permanent
# Appliquer toutes les règles de firewall en persistance
firewall-cmd --reload

# Vérifier
# Afficher toutes les règles de la zone active
firewall-cmd --list-all
# Vérifier que wg100 est bien dans la zone trusted
firewall-cmd --zone=trusted --list-all

# Tester depuis un master
# Tester la connectivité vers l'API Kubernetes via HAProxy
curl -k https://192.168.0.254:6443 2>&1 | head -3
# Attendu : SSL_ERROR_ZERO_RETURN (normal si cluster pas encore initialisé)
# ou réponse JSON si cluster déjà up

# Vérifier si Docker est déjà installé
# Vérifier si Docker est déjà présent sur le système
docker --version 2>/dev/null && echo "✅ Docker déjà installé" || echo "❌ Docker absent"

# Installer Docker si absent
if ! command -v docker &>/dev/null; then
  dnf install -y docker-ce docker-ce-cli containerd.io
  systemctl enable --now docker
  echo "✅ Docker installé"
fi

# Créer le fichier docker-compose.yml
cat > /opt/xsel-haproxy/docker-compose.yml << 'EOF'
version: "3.8"

services:
  haproxy:
    image: haproxy:3.0-alpine
    container_name: xsel-haproxy-lb
    restart: always
    network_mode: host
    volumes:
      - ./config/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
      - ./logs:/var/log/haproxy
    cap_add:
      - NET_ADMIN
      - NET_BIND_SERVICE
    healthcheck:
      test: ["CMD", "haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"]
      interval: 30s
      timeout: 10s
      retries: 3
EOF

echo "✅ docker-compose.yml créé"

cat > /opt/xsel-haproxy/config/haproxy.cfg << 'HAEOFEOF'
# =============================================================
# XSEL — HAProxy Configuration
# Serveur dédié Load Balancer
# Version : 1.0 — Mai 2026
# =============================================================

global
    # stdout obligatoire dans Docker — sinon docker logs est vide
    log stdout format raw local0
    stats socket /run/haproxy/admin.sock mode 660 level admin expose-fd listeners
    stats timeout 30s
    maxconn 50000

defaults
    log     global
    mode    tcp
    option  tcplog
    option  dontlognull
    timeout connect 5s
    timeout client  1h
    timeout server  1h

# =============================================================
# STATS — Interface de monitoring HAProxy
# =============================================================
listen stats
    bind *:8404
    mode http
    stats enable
    stats uri /stats
    stats refresh 10s
    stats admin if TRUE
    stats show-legends
    stats show-node

# =============================================================
# KUBERNETES API — Accès Control Plane
# TCP 6443 → Masters (via WG100)
# =============================================================
frontend k8s_api_frontend
    bind *:6443
    mode tcp
    option tcplog
    default_backend k8s_api_masters

backend k8s_api_masters
    mode tcp
    option tcp-check
    balance roundrobin
    server xsel-master-01 192.168.0.1:6443 check inter 5s fall 3 rise 2
    server xsel-master-02 192.168.0.2:6443 check inter 5s fall 3 rise 2

# =============================================================
# vCLUSTER DEV — Trafic applicatif HTTP
# TCP 80 → DevNodes NGINX Ingress NodePort 30080
# =============================================================
frontend dev_http_frontend
    bind *:80
    mode tcp
    option tcplog
    default_backend dev_http_workers

backend dev_http_workers
    mode tcp
    option tcp-check
    balance roundrobin
    server xsel-devnode-01 192.168.1.1:30080 check inter 5s fall 3 rise 2
    server xsel-devnode-02 192.168.1.2:30080 check inter 5s fall 3 rise 2
    server xsel-devnode-03 192.168.1.3:30080 check inter 5s fall 3 rise 2

# =============================================================
# vCLUSTER DEV — Trafic applicatif HTTPS
# TCP 443 → DevNodes NGINX Ingress NodePort 30443
# =============================================================
frontend dev_https_frontend
    bind *:443
    mode tcp
    option tcplog
    default_backend dev_https_workers

backend dev_https_workers
    mode tcp
    option tcp-check
    balance roundrobin
    server xsel-devnode-01 192.168.1.1:30443 check inter 5s fall 3 rise 2
    server xsel-devnode-02 192.168.1.2:30443 check inter 5s fall 3 rise 2
    server xsel-devnode-03 192.168.1.3:30443 check inter 5s fall 3 rise 2

# =============================================================
# MySQL — Accès externe base de données
# TCP 3306 → DevNodes NodePort (ProxySQL)
# =============================================================
frontend mysql_frontend
    bind *:3306
    mode tcp
    option tcplog
    default_backend mysql_workers

backend mysql_workers
    mode tcp
    option tcp-check
    balance roundrobin
    server xsel-devnode-01 192.168.1.1:30432 check inter 5s fall 3 rise 2
    server xsel-devnode-02 192.168.1.2:30432 check inter 5s fall 3 rise 2
    server xsel-devnode-03 192.168.1.3:30432 check inter 5s fall 3 rise 2

# =============================================================
# PostgreSQL PGBouncer — Accès externe avec connection pooling
# TCP 5432 → DevNodes NodePort (PGBouncer)
# =============================================================
frontend postgres_pgbouncer_frontend
    bind *:5432
    mode tcp
    option tcplog
    default_backend postgres_pgbouncer_workers

backend postgres_pgbouncer_workers
    mode tcp
    option tcp-check
    balance roundrobin
    server xsel-devnode-01 192.168.1.1:30432 check inter 5s fall 3 rise 2
    server xsel-devnode-02 192.168.1.2:30432 check inter 5s fall 3 rise 2
    server xsel-devnode-03 192.168.1.3:30432 check inter 5s fall 3 rise 2

# =============================================================
# PostgreSQL Direct — Accès sans base obligatoire (admin)
# TCP 5433 → DevNodes NodePort (PostgreSQL primaire)
# =============================================================
frontend postgres_direct_frontend
    bind *:5433
    mode tcp
    option tcplog
    default_backend postgres_direct_workers

backend postgres_direct_workers
    mode tcp
    option tcp-check
    balance roundrobin
    server xsel-devnode-01 192.168.1.1:30433 check inter 5s fall 3 rise 2
    server xsel-devnode-02 192.168.1.2:30433 check inter 5s fall 3 rise 2
    server xsel-devnode-03 192.168.1.3:30433 check inter 5s fall 3 rise 2

# =============================================================
# vCLUSTER CLX (CLIENTS) — Trafic HTTP
# Décommenter et adapter quand les workers clients sont ajoutés
# =============================================================
# frontend clx_http_frontend
#     bind *:8080
#     mode tcp
#     option tcplog
#     default_backend clx_http_workers
#
# backend clx_http_workers
#     mode tcp
#     option tcp-check
#     balance roundrobin
#     server xsel-clxnode-01 192.168.10X.Y:30080 check inter 5s fall 3 rise 2
#     server xsel-clxnode-02 192.168.10X.Z:30080 check inter 5s fall 3 rise 2

# =============================================================
# vCLUSTER CLX (CLIENTS) — Trafic HTTPS
# =============================================================
# frontend clx_https_frontend
#     bind *:8443
#     mode tcp
#     option tcplog
#     default_backend clx_https_workers
#
# backend clx_https_workers
#     mode tcp
#     option tcp-check
#     balance roundrobin
#     server xsel-clxnode-01 192.168.10X.Y:30443 check inter 5s fall 3 rise 2
#     server xsel-clxnode-02 192.168.10X.Z:30443 check inter 5s fall 3 rise 2
HAEOFEOF

echo "✅ haproxy.cfg créé"

cd /opt/xsel-haproxy

# Valider la configuration avant de démarrer
docker run --rm -v $(pwd)/config/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro \
  haproxy:3.0-alpine haproxy -c -f /usr/local/etc/haproxy/haproxy.cfg
# Attendu : Configuration file is valid

# Démarrer
# Démarrer HAProxy en arrière-plan
docker compose up -d

# Vérifier
# Vérifier le statut du conteneur
docker compose ps
# Afficher les logs du conteneur HAProxy
docker logs xsel-haproxy-lb

cd /opt/xsel-haproxy

# Voir les logs en temps réel
# Suivre les logs en temps réel
docker logs -f xsel-haproxy-lb

# Recharger la config sans downtime
# Recharger la configuration à chaud sans interruption de trafic
docker kill -s HUP xsel-haproxy-lb

# Redémarrer
# Redémarrer le conteneur
docker compose restart

# Arrêter
# Arrêter et supprimer le conteneur
docker compose down

# Mettre à jour l'image HAProxy
# Récupérer la dernière version de l'image HAProxy
docker compose pull
# Démarrer HAProxy en arrière-plan
docker compose up -d

# Vérifier le container
# Vérifier l'état du conteneur HAProxy
docker compose -f /opt/xsel-haproxy/docker-compose.yml ps

# API Kubernetes via HAProxy
# Tester l'accès à l'API Kubernetes via HAProxy
curl -k https://192.168.0.254:6443/version

# Stats HAProxy
# Accéder aux statistiques HAProxy
curl http://192.168.0.254:8404/stats

# Ports actifs
# Lister les ports TCP en écoute sur le serveur
ss -tlnp | grep -E "80|443|6443|3306|5432|5433|8404"

# À exécuter sur MASTER-01 ET MASTER-02

# Vérifier si un container HAProxy tourne
# Vérifier si un conteneur HAProxy est en cours d'exécution
docker ps | grep haproxy

# Arrêter et supprimer le container
# Arrêter le conteneur HAProxy (silencieux si absent)
docker stop xsel-haproxy-lb 2>/dev/null || true
# Supprimer le conteneur HAProxy
docker rm xsel-haproxy-lb 2>/dev/null || true

# Supprimer l'image
# Supprimer l'image HAProxy locale
docker rmi haproxy 2>/dev/null || true

# Vérifier que les ports sont libres
# S'assurer que les ports 80, 443 et 6443 sont libres
ss -tlnp | grep -E ":80|:443|:6443"

# Supprimer le dossier de config
# Supprimer le dossier de configuration HAProxy
rm -rf /opt/xsel-haproxy

# Reset avec containerd explicite
# Réinitialiser kubeadm en précisant le socket containerd
sudo kubeadm reset -f --cri-socket unix:///var/run/containerd/containerd.sock

# Nettoyage Kubernetes
# Supprimer la configuration du cluster Kubernetes
sudo rm -rf /etc/kubernetes/
# Supprimer les données du kubelet
sudo rm -rf /var/lib/kubelet/
# Supprimer les données etcd
sudo rm -rf /var/lib/etcd/
# Supprimer la configuration kubectl de l'utilisateur
sudo rm -rf ~/.kube/

# Nettoyer les configurations CNI (Calico)
# Supprimer les configurations CNI résiduelles
sudo rm -rf /etc/cni/net.d/
# Supprimer les données CNI résiduelles
sudo rm -rf /var/lib/cni/

# Nettoyer iptables rules créées par Kubernetes
# Vider toutes les règles iptables IPv4 créées par Kubernetes
sudo iptables -F && sudo iptables -t nat -F && sudo iptables -t mangle -F && sudo iptables -X
# Vider toutes les règles iptables IPv6
sudo ip6tables -F && sudo ip6tables -t nat -F && sudo ip6tables -t mangle -F && sudo ip6tables -X

# Nettoyer les interfaces réseau virtuelles de Kubernetes/Calico
# Supprimer l'interface bridge CNI si elle existe
sudo ip link delete cni0 2>/dev/null || true
# Supprimer l'interface Flannel si elle existe
sudo ip link delete flannel.1 2>/dev/null || true
# Supprimer toutes les interfaces veth virtuelles résiduelles
sudo ip link show | grep veth | awk '{print $2}' | cut -d@ -f1 | xargs -I {} sudo ip link delete {} 2>/dev/null || true

# Nettoyer les routes liées à Calico
# Supprimer les routes BGP ajoutées par Calico
sudo ip route flush proto bird 2>/dev/null || true

# Redémarrer containerd
# Redémarrer containerd pour repartir d'un état propre
sudo systemctl restart containerd
# Vérifier que tout est propre
echo "=== Vérification post-nettoyage ==="
echo "Docker containers:"
docker ps
echo ""
echo "HAProxy status:"
# Vérifier si un conteneur HAProxy est en cours d'exécution
docker ps | grep haproxy
echo ""
echo "WireGuard interfaces:"
ip addr show wg0 | grep inet
ip addr show wg100 | grep inet
echo ""
echo "VIP status:"
ip addr show | grep -E "(10.0.0.10|192.168.0.254)"
echo ""
echo "Kubernetes cleaned:"
ls /etc/kubernetes/ 2>/dev/null || echo "/etc/kubernetes/ supprimé"
ls /var/lib/kubelet/ 2>/dev/null || echo "/var/lib/kubelet/ supprimé"

# Se connecter à MASTER-01 via SSH
ssh root@173.249.55.153
# Créer le répertoire de travail pour les manifests Kubernetes
mkdir -p /root/k8s-xsel
# Se positionner dans le répertoire de travail
cd /root/k8s-xsel

vi kubeadm-config.yaml

cat > /root/k8s-xsel/kubeadm-config.yaml << 'EOF'
# ClusterConfiguration
apiVersion: kubeadm.k8s.io/v1beta3
kind: ClusterConfiguration
kubernetesVersion: v1.29.15
clusterName: xsel-cluster
controlPlaneEndpoint: "192.168.0.254:6443"
networking:
  serviceSubnet: "10.96.0.0/16"
  podSubnet: "172.16.0.0/16"
  dnsDomain: "cluster.local"
apiServer:
  certSANs:
  - "192.168.0.254"
  - "192.168.0.1"
  - "192.168.0.2"
  - "10.0.0.10"
  - "10.0.0.1"
  - "10.0.0.2"
  - "173.249.55.153"
  - "207.180.237.139"
  - "xsel-master-01"
  - "xsel-master-02"
  - "xsel-master-01.xsel-services.com"
  - "xsel-master-02.xsel-services.com"
  extraArgs:
    authorization-mode: "Node,RBAC"
controllerManager:
  extraArgs:
    bind-address: "0.0.0.0"
    allocate-node-cidrs: "false"
scheduler:
  extraArgs:
    bind-address: "0.0.0.0"
etcd:
  local:
    dataDir: /var/lib/etcd
    extraArgs:
      listen-metrics-urls: "http://0.0.0.0:2381"
---
# InitConfiguration
apiVersion: kubeadm.k8s.io/v1beta3
kind: InitConfiguration
localAPIEndpoint:
  advertiseAddress: "192.168.0.1"
  bindPort: 6443
nodeRegistration:
  criSocket: "unix:///var/run/containerd/containerd.sock"
  name: "xsel-master-01"
  kubeletExtraArgs:
    node-ip: "192.168.0.1"
  taints:
  - effect: NoSchedule
    key: node-role.kubernetes.io/control-plane
---
# KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
serverTLSBootstrap: true
---
# KubeProxyConfiguration
apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
mode: "iptables"
EOF

# Vérifier l'état du service kubelet
systemctl status kubelet
# Activer kubelet au démarrage
systemctl enable kubelet.service

ls /etc/kubernetes/ 2>/dev/null && echo "ERREUR: /etc/kubernetes existe encore" || echo "OK"
ls /var/lib/kubelet/ 2>/dev/null && echo "ERREUR: /var/lib/kubelet existe encore" || echo "OK"

# Tester la connectivité vers MASTER-02 via WG100
ping -c 2 192.168.0.2
# Tester la connectivité vers DEVNODE-01 via WG100
ping -c 2 192.168.1.1
# Tester la connectivité vers DEVNODE-02 via WG100
ping -c 2 192.168.1.2

# Tester l'accès à HAProxy avant l'initialisation du cluster
curl -k https://192.168.0.254:6443 2>&1 | head -5

# Se positionner dans le répertoire de travail
cd /root/k8s-xsel
# Initialiser le cluster Kubernetes depuis la configuration et téléverser les certificats pour le second master
sudo kubeadm init --config kubeadm-config.yaml --upload-certs

kubeadm join 192.168.0.254:6443 --token <TOKEN> \
    --discovery-token-ca-cert-hash sha256:<HASH> \
    --control-plane \
    --certificate-key <CERT-KEY>
    kubeadm join 192.168.0.254:6443 --token 8rloti.fnsr95d2nqhb7vt1 \
    --discovery-token-ca-cert-hash sha256:bcdb06a82173f675ad89a52512f73233075235aec4061b9cfa564c0003ddad4b \
    --control-plane --certificate-key 39c9f3461ff3f2c75cbc626ea5e2f1a0db1f795c29d65ef38512fb1858e943ce \
    --cri-socket unix:///var/run/containerd/containerd.sock \
    --apiserver-advertise-address 192.168.0.2

kubeadm join 192.168.0.254:6443 --token <TOKEN> \
    --discovery-token-ca-cert-hash sha256:<HASH>
    kubeadm join 192.168.0.254:6443 \
    --token rpk5ec.8chrzyx60vzs4lj9 \
    --discovery-token-ca-cert-hash sha256:bcdb06a82173f675ad89a52512f73233075235aec4061b9cfa564c0003ddad4b \
    --cri-socket unix:///var/run/containerd/containerd.sock

# Créer le répertoire de configuration kubectl
mkdir -p $HOME/.kube
# Copier le kubeconfig admin généré par kubeadm
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# Donner la propriété du fichier à l'utilisateur courant
sudo chown $(id -u):$(id -g) $HOME/.kube/config

# Vérifier
# Afficher les nœuds du cluster et leur statut
kubectl get nodes
# Vérifier les pods du plan de contrôle Kubernetes
kubectl get pods -n kube-system

# Se connecter à MASTER-02
# Se connecter à MASTER-02 via SSH
ssh root@207.180.237.139
# Vérifier les prérequis
# Vérifier l'état du service kubelet
systemctl status kubelet
# Devrait être "inactive (dead)"

ls /etc/kubernetes/ 2>/dev/null && echo "ERREUR" || echo "OK"
ls /var/lib/kubelet/ 2>/dev/null && echo "ERREUR" || echo"OK"

# Sur MASTER-02
# Utiliser la commande sauvegardée à l'étape 2.2
# IMPORTANT: Ajouter ces paramètres à la commande de join:
sudo kubeadm join 192.168.0.254:6443 \
    --token <TOKEN> \
    --discovery-token-ca-cert-hash sha256:<HASH> \
    --control-plane \
    --certificate-key <CERT-KEY> \
    --cri-socket unix:///var/run/containerd/containerd.sock \
    --apiserver-advertise-address 192.168.0.2
# Cela prend environ 2 minutes

# Sur MASTER-02
# Créer le répertoire de configuration kubectl
mkdir -p $HOME/.kube
# Copier le kubeconfig admin généré par kubeadm
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# Donner la propriété du fichier à l'utilisateur courant
sudo chown $(id -u):$(id -g) $HOME/.kube/config

# Vérifier — devrait montrer les 2 masters
# Afficher les nœuds du cluster et leur statut
kubectl get nodes

# Se connecter
# Se connecter à DEVNODE-01 via SSH
ssh root@207.180.196.59
# Utiliser la commande worker sauvegardée à l'étape 2.2
sudo kubeadm join 192.168.0.254:6443 \
    --token <TOKEN> \
    --discovery-token-ca-cert-hash sha256:<HASH> \
    --cri-socket unix:///var/run/containerd/containerd.sock
# Environ 1 minute

# Se connecter
# Se connecter à DEVNODE-02 via SSH
ssh root@149.102.138.247
# Même commande que DEVNODE-01
sudo kubeadm join 192.168.0.254:6443 \
    --token <TOKEN> \
    --discovery-token-ca-cert-hash sha256:<HASH> \
    --cri-socket unix:///var/run/containerd/containerd.sock
# Ir Environ 1 minute

# Sur MASTER-01
# Afficher les nœuds avec leur IP interne et version
kubectl get nodes -o wide
# Devrait montrer les 4 nœuds en Ready:
# NAME STATUS ROLE AGE VERSION
INTERNAL-IP
# xsel-master-01 Ready control-plane 15m v1.29.15
192.168.0.1

# Se positionner dans le répertoire de travail
cd /root/k8s-xsel
# Télécharger le manifeste Calico CNI v3.28.0
curl https://raw.githubusercontent.com/projectcalico/calico/v3.28.0/manifests/calico.yaml -O

# Étape 1 — Décommenter et corriger CALICO_IPV4POOL_CIDR
# Décommenter la variable CALICO_IPV4POOL_CIDR
sed -i 's/# - name: CALICO_IPV4POOL_CIDR/- name: CALICO_IPV4POOL_CIDR/' calico.yaml
# Remplacer le CIDR par défaut par le CIDR pods XSEL (172.16.0.0/16)
sed -i 's/#   value: "192.168.0.0\/16"/  value: "172.16.0.0\/16"/' calico.yaml

# Étape 2 — Corriger IPIP et VXLAN
# (les valeurs sont parfois inversées dans le manifeste par défaut)
sed -i '/CALICO_IPV4POOL_IPIP/{n; s/value: "Always"/value: "Never"/}' calico.yaml
sed -i '/CALICO_IPV4POOL_VXLAN/{n; s/value: "Never"/value: "Always"/}' calico.yaml

# Étape 3 — Vérification globale
grep -A 1 "CALICO_IPV4POOL_CIDR\|CALICO_IPV4POOL_IPIP\|CALICO_IPV4POOL_VXLAN" calico.yaml | grep -v "^--$"

- name: CALICO_IPV4POOL_CIDR
  value: "172.16.0.0/16"
- name: CALICO_IPV4POOL_IPIP
  value: "Never"
- name: CALICO_IPV4POOL_VXLAN
  value: "Always"

# Appliquer Calico
# Déployer Calico CNI dans le cluster
kubectl apply -f calico.yaml
# Attendre que Calico démarre (2-3 minutes)
echo "Attente du démarrage de Calico..."
# Attendre que tous les pods calico-node soient opérationnels (max 5 min)
kubectl wait --for=condition=ready pod -l k8s-app=calico-node -n kube-system --timeout=300s
# Vérifier les pods Calico
# Vérifier l'état des pods Calico
kubectl get pods -n kube-system | grep calico

 Tous les pods calico-node doivent être 1 / 1 Running

#D'abord approuver les CSR pending actuels :

# Lister les demandes de signature de certificat en attente
kubectl get csr | grep Pending

# Approuver automatiquement tous les CSR en attente
kubectl get csr --no-headers | grep Pending | awk '{print $1}' | xargs kubectl certificate approve

cat <<EOF | kubectl apply -f -
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: auto-approve-kubelet-serving-csrs
subjects:
- kind: Group
  name: system:nodes
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: system:certificates.k8s.io:certificatesigningrequests:selfnodeclient
  apiGroup: rbac.authorization.k8s.io
EOF

# Vérifier le statut final des CSR
kubectl get csr

#Vérifier l'état global du cluster:

# Afficher les nœuds du cluster et leur statut
kubectl get nodes

# Pods système
# Lister tous les pods de tous les namespaces
kubectl get pods -A

# Routes VXLAN (le problème initial)
# Vérifier la présence des routes VXLAN Calico
ip route | grep 172.16

# Sur MASTER-01
# Désactiver BGP (qui empêche VXLAN de fonctionner correctement)
cat <<EOF | calicoctl apply -f -
apiVersion: projectcalico.org/v3
kind: BGPConfiguration
metadata:
  name: default
spec:
  nodeToNodeMeshEnabled: false
  asNumber: 64512
EOF

# 1) Vérifier si la variable est déjà présente dans le DaemonSet
kubectl get daemonset calico-node -n kube-system \
  -o jsonpath='{range .spec.template.spec.containers[0].env[*]}{.name}{"\n"}{end}' \
  | grep IP_AUTODETECTION

# 2) Si ABSENTE → appliquer le patch
kubectl patch daemonset calico-node -n kube-system --type='json' -p='[
  {
    "op": "add",
    "path": "/spec/template/spec/containers/0/env/-",
    "value": {
      "name": "IP_AUTODETECTION_METHOD",
      "value": "interface=wg100"
    }
  }
]'

# Vérifier que le rollout est terminé
# Attendre la fin du redémarrage du DaemonSet Calico
kubectl rollout status daemonset calico-node -n kube-system

# 3) Si PRÉSENTE → ignorer le patch, juste redémarrer les pods Calico
# Forcer le redémarrage de tous les pods Calico
kubectl delete pod -n kube-system -l k8s-app=calico-node

# Laisser le temps aux pods de redémarrer
sleep 30

# Vérifier l'état des pods Calico
kubectl get pods -n kube-system | grep calico

# Attendre que les pods Calico soient prêts (max 3 min)
kubectl wait --for=condition=ready pod -l k8s-app=calico-node -n kube-system --timeout=180s

# Vérifier que le nœud est maintenant Ready
# Afficher les nœuds du cluster et leur statut
kubectl get nodes
# Vérifier les pods système avec leur placement sur les nœuds
kubectl get pods -n kube-system -o wide

# Sur MASTER-01
# Se positionner dans le répertoire de travail
cd /root/k8s-xsel
# Télécharger calicoctl
# Télécharger le binaire calicoctl v3.28.0
curl -L https://github.com/projectcalico/calico/releases/download/v3.28.0/calicoctl-linux-amd64 -o calicoctl

# Rendre le binaire exécutable
chmod +x calicoctl

# Installer calicoctl globalement
sudo mv calicoctl /usr/local/bin/
# Vérifier
# Vérifier que calicoctl est correctement installé
calicoctl version

cat > /root/k8s-xsel/calico-ippool.yaml << 'EOF'
---
apiVersion: projectcalico.org/v3
kind: IPPool
metadata:
  name: master-01-pool
spec:
  cidr: 172.16.1.0/24
  blockSize: 26
  ipipMode: Never
  vxlanMode: Always
  natOutgoing: true
  nodeSelector: kubernetes.io/hostname == "xsel-master-01"
---
apiVersion: projectcalico.org/v3
kind: IPPool
metadata:
  name: master-02-pool
spec:
  cidr: 172.16.2.0/24
  blockSize: 26
  ipipMode: Never
  vxlanMode: Always
  natOutgoing: true
  nodeSelector: kubernetes.io/hostname == "xsel-master-02"
---
apiVersion: projectcalico.org/v3
kind: IPPool
metadata:
  name: devnode-01-pool
spec:
  cidr: 172.16.11.0/24
  blockSize: 26
  ipipMode: Never
  vxlanMode: Always
  natOutgoing: true
  nodeSelector: kubernetes.io/hostname == "xsel-devnode-01"
---
apiVersion: projectcalico.org/v3
kind: IPPool
metadata:
  name: devnode-02-pool
spec:
  cidr: 172.16.12.0/24
  blockSize: 26
  ipipMode: Never
  vxlanMode: Always
  natOutgoing: true
  nodeSelector: kubernetes.io/hostname == "xsel-devnode-02"
EOF

# Sur MASTER-01
# Créer la FelixConfiguration pour forcer le dataplane VXLAN
cat > /root/k8s-xsel/felixconfiguration.yaml << 'EOF'
apiVersion: projectcalico.org/v3
kind: FelixConfiguration
metadata:
  name: default
spec:
  vxlanEnabled: true
  vxlanPort: 4789
  vxlanVNI: 4096
  #vxlanMTU: 1450    # À décommenter et ajuster si problème de connectivité pod-to-pod
EOF

# Appliquer
# Appliquer la configuration FelixConfiguration pour activer VXLAN
calicoctl apply -f /root/k8s-xsel/felixconfiguration.yaml

# Vérifier
# Vérifier les paramètres VXLAN dans la FelixConfiguration
kubectl get felixconfiguration default -o yaml | grep -E "vxlan|mtu"

# Voir les pools existants
# Lister les IP pools Calico existants avec les détails
calicoctl get ippool -o wide
# Supprimer le pool par défaut
# Supprimer le pool IP par défaut Calico
calicoctl delete ippool default-ipv4-ippool
# Appliquer les pools
# Appliquer les IP pools personnalisés par nœud
calicoctl apply -f /root/k8s-xsel/calico-ippool.yaml
# Vérifier les pools
# Lister les IP pools Calico existants avec les détails
calicoctl get ippool -o wide

# Sur MASTER-01

# Redémarrer le DaemonSet Calico
# Redémarrer le DaemonSet Calico pour prendre en compte les nouveaux pools
kubectl rollout restart daemonset calico-node -n kube-system

# 1. Redémarrer CoreDNS
# Redémarrer CoreDNS pour actualiser la configuration réseau
kubectl rollout restart deployment coredns -n kube-system

# 2. Redémarrer Calico kube-controllers
# Redémarrer les contrôleurs Calico
kubectl rollout restart deployment calico-kube-controllers -n kube-system

# 3. Attendre que les nouveaux pods démarrent
# Attendre que CoreDNS soit disponible
kubectl rollout status deployment coredns -n kube-system
# Attendre que les contrôleurs Calico soient disponibles
kubectl rollout status deployment calico-kube-controllers -n kube-system

# 4. Vérifier les nouvelles IPs
# Vérifier les IPs assignées à CoreDNS et Calico controllers
kubectl get pods -n kube-system -o wide | grep -E "coredns|calico-kube"

# Résultat attendu :
# coredns: 172.16.1.x (sur master-01)
# calico-kube-controllers: 172.16.1.x (sur master-01)

# Vider la table de suivi des connexions sur DEVNODE-01 après changement réseau
ssh root@192.168.1.1 "conntrack -F 2>/dev/null; echo OK"
# Vider la table de suivi des connexions sur DEVNODE-02
ssh root@192.168.1.2 "conntrack -F 2>/dev/null; echo OK"

# Activer serverTLSBootstrap sur tous les nodes
for node_ip in 192.168.0.1 192.168.0.2 192.168.1.1 192.168.1.2; do
  ssh root@$node_ip "
    grep -q 'serverTLSBootstrap' /var/lib/kubelet/config.yaml || \
      echo 'serverTLSBootstrap: true' >> /var/lib/kubelet/config.yaml
    # Redémarrer kubelet après containerd
    systemctl restart kubelet
  "
done

# Attendre la génération des CSRs
sleep 10
# Lister les demandes de signature de certificat en attente
kubectl get csr | grep Pending

# Approuver tous les CSRs en attente
kubectl get csr --no-headers | grep Pending | awk '{print $1}' | \
  xargs kubectl certificate approve

# Vérifier — aucun Pending restant
# Lister les demandes de signature de certificat en attente
kubectl get csr | grep Pending

# Tester la connectivité pod → API server
kubectl run test-api --image=nicolaka/netshoot --restart=Never \
  --command -- sh -c "curl -sk --max-time 5 https://10.96.0.1/healthz; echo"

sleep 10
# Vérifier la sortie du pod de test (attendu : "ok")
kubectl logs test-api
# Résultat attendu : ok ✅
# Supprimer le pod de test temporaire
kubectl delete pod test-api

# Afficher les nœuds avec leur IP interne et version
kubectl get nodes -o wide
# Vérifier les pods système avec leur placement sur les nœuds
kubectl get pods -n kube-system -o wide

# Créer test-pod-1 sur DEVNODE-01
kubectl run test-pod-1 --image=nicolaka/netshoot   --overrides='{"spec": {"nodeSelector": {"kubernetes.io/hostname": "xsel-devnode-01"}}}'   --command -- sleep 3600

# Créer test-pod-2 sur DEVNODE-02
kubectl run test-pod-2 --image=nicolaka/netshoot   --overrides='{"spec": {"nodeSelector": {"kubernetes.io/hostname": "xsel-devnode-02"}}}'   --command -- sleep 3600

# Attendre que les pods soient prêts
kubectl wait --for=condition=Ready pod/test-pod-1 --timeout=60s
kubectl wait --for=condition=Ready pod/test-pod-2 --timeout=60s

# Vérifier les IPs et les nodes
kubectl get pods test-pod-1 test-pod-2 -o wide
# Résultat attendu :
# test-pod-1   Running   xsel-devnode-01   172.16.11.x
# test-pod-2   Running   xsel-devnode-02   172.16.12.x

# Récupérer les IPs
# Récupérer l'IP du pod 1 pour le test ping
POD1_IP=$(kubectl get pod test-pod-1 -o jsonpath='{.status.podIP}')
# Récupérer l'IP du pod 2
POD2_IP=$(kubectl get pod test-pod-2 -o jsonpath='{.status.podIP}')
echo "Pod 1 IP (devnode-01): $POD1_IP"
echo "Pod 2 IP (devnode-02): $POD2_IP"

# Test ping cross-node depuis test-pod-1 → test-pod-2
echo "=== Test ping DEVNODE-01 → DEVNODE-02 ==="
# Tester la connectivité pod-to-pod : DEVNODE-01 vers DEVNODE-02
kubectl exec test-pod-1 -- ping -c 5 $POD2_IP

# Test ping cross-node depuis test-pod-2 → test-pod-1
echo "=== Test ping DEVNODE-02 → DEVNODE-01 ==="
# Tester la connectivité pod-to-pod : DEVNODE-02 vers DEVNODE-01
kubectl exec test-pod-2 -- ping -c 5 $POD1_IP

# Nettoyage
# Supprimer les pods de test
kubectl delete pod test-pod-1 test-pod-2

5 packets transmitted, 5 received, 0% packet loss

curl http://192.168.0.254:8404/ -u admin:xsel2025 | grep k 8s_api_backend

# Sur MASTER-01

# Ajouter le repo Helm (si pas encore fait)
# Ajouter le repo Helm officiel du Metrics Server
helm repo add metrics-server https://kubernetes-sigs.github.io/metrics-server/
# Mettre à jour le cache des repos Helm
helm repo update

# Installer le Metrics Server
# --kubelet-insecure-tls est nécessaire car les kubelets utilisent des certificats auto-signés
helm upgrade --install metrics-server metrics-server/metrics-server \
  --namespace kube-system \
  --set args[0]="--kubelet-insecure-tls" \
  --wait \
  --timeout 2m

echo "✅ Metrics Server installé"

# Vérifier que le pod est Running
# Vérifier que le pod Metrics Server est en Running
kubectl get pods -n kube-system | grep metrics-server
# Résultat attendu :
# metrics-server-<hash>   1/1   Running   0   ...

# Vérifier le service
# Vérifier le service Metrics Server
kubectl get svc -n kube-system metrics-server

# Métriques des nœuds
# Afficher la consommation CPU/RAM de chaque nœud
kubectl top nodes
# Résultat attendu :
# NAME              CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
# xsel-master-01    <valeur>m    <x>%   <valeur>Mi      <x>%
# xsel-master-02    <valeur>m    <x>%   <valeur>Mi      <x>%
# xsel-devnode-01   <valeur>m    <x>%   <valeur>Mi      <x>%
# xsel-devnode-02   <valeur>m    <x>%   <valeur>Mi      <x>%

# Métriques des pods (namespace kube-system)
# Afficher la consommation CPU/RAM des pods système
kubectl top pods -n kube-system

✅ Metrics Server    : installé dans kube-system
✅ kubectl top nodes : fonctionnel
✅ kubectl top pods  : fonctionnel
✅ HPA/VPA           : prêts à être utilisés
✅ K8s Dashboard     : métriques disponibles (étape 11)

# Sur MASTER-01
# Se positionner dans le répertoire de travail
cd /root/k8s-xsel

# Télécharger le manifeste NGINX Ingress Controller
# Télécharger le manifeste NGINX Ingress Controller pour bare-metal
curl -o ingress-nginx.yaml https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.9.4/deploy/static/provider/baremetal/deploy.yaml

# Vérifier que le fichier est téléchargé
# Vérifier que le fichier a bien été téléchargé
ls -lh ingress-nginx.yaml

# Appliquer le manifeste
# Déployer le contrôleur NGINX Ingress
kubectl apply -f ingress-nginx.yaml

# Attendre que le controller soit prêt
# Attendre que le pod NGINX Ingress soit opérationnel (max 2 min)
kubectl wait --namespace ingress-nginx   --for=condition=ready pod   --selector=app.kubernetes.io/component=controller   --timeout=120s

# Vérifier
# Vérifier le pod NGINX Ingress et son nœud
kubectl get pods -n ingress-nginx -o wide

# Sur MASTER-01
# Patcher le service pour forcer les NodePorts 30080 et 30443
kubectl patch svc ingress-nginx-controller -n ingress-nginx --type='json' -p='[
  {"op":"replace","path":"/spec/ports/0/nodePort","value":30080},
  {"op":"replace","path":"/spec/ports/1/nodePort","value":30443}
]'

# Vérifier les NodePorts
# Vérifier les NodePorts 30080/30443 du service
kubectl get svc ingress-nginx-controller -n ingress-nginx
# Résultat attendu : 80:30080/TCP,443:30443/TCP

# Vérifier les pods
# Vérifier le pod NGINX Ingress et son nœud
kubectl get pods -n ingress-nginx -o wide

# Vérifier tous les objets
# Lister toutes les ressources du namespace ingress-nginx
kubectl get all -n ingress-nginx

# Créer une application de test
cat > /root/k8s-xsel/test-app.yaml << 'EOF'
apiVersion: v1
kind: Namespace
metadata:
  name: test-app
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world
  namespace: test-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello-world
  template:
    metadata:
      labels:
        app: hello-world
    spec:
      containers:
      - name: hello
        image: gcr.io/google-samples/hello-app:1.0
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: hello-world
  namespace: test-app
spec:
  selector:
    app: hello-world
  ports:
  - port: 80
    targetPort: 8080
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-world
  namespace: test-app
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: hello.xsel-test.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: hello-world
            port:
              number: 80
EOF

# Appliquer l'application de test
# Déployer l'application de test dans le namespace test-app
kubectl apply -f /root/k8s-xsel/test-app.yaml

# Attendre que les pods démarrent
# Attendre que le Deployment soit disponible (max 2 min)
kubectl wait --for=condition=available --timeout=120s deployment/hello-world -n test-app
# Vérifier les ressources
# Vérifier toutes les ressources déployées dans test-app
kubectl get all -n test-app
# Vérifier la règle Ingress de l'application de test
kubectl get ingress -n test-app
# Tester l'accès via NodePort
curl -H "Host: hello.xsel-test.local" http://192.168.1.1:30080curl -H "Host: hello.xsel-test.local" http://192.168.1.2:30080
# Tester via le VIP HAProxy (si configuré)
curl -H "Host: hello.xsel-test.local" http://192.168.0.254
# Devrait retourner:

# Hello, world!
# Version: 1.0.0
# Hostname: hello-world-xxxxxxxxxx-xxxxx

Internet
    │
    ▼
DNS : hello.xsel-test.local → 95.111.238.94 (IP publique HAProxy)
    │
    ▼
HAProxy dédié (xsel-jumphost-01)
IP publique : 95.111.238.94
IP WG100    : 192.168.0.254
    │  :80 → round-robin
    ├──────────────────────────┐
    ▼                          ▼
DEVNODE-01                 DEVNODE-02
192.168.1.1:30080          192.168.1.2:30080
    │                          │
    └──────────┬───────────────┘
               ▼
    NGINX Ingress Controller
    Host: hello.xsel-test.local → Service hello-world
               │
               ▼
    Kubernetes Service (ClusterIP)
               │
    ┌──────────┴──────────┐
    ▼                     ▼
Pod 1                   Pod 2
172.16.11.X             172.16.12.X
(DEVNODE-01)            (DEVNODE-02)

# Sur MASTER-01
# Se positionner dans le répertoire de travail
cd /root/k8s-xsel
# Télécharger le manifeste
# Télécharger le manifeste du Kubernetes Dashboard v2.7.0
curl -o kubernetes-dashboard.yaml https://raw.githubusercontent.com/kubernetes/dashboard/v2.7.0/aio/deploy/recommended.yaml
# Appliquer
# Déployer le Kubernetes Dashboard
kubectl apply -f kubernetes-dashboard.yaml
# Vérifier l'installation
# Vérifier les pods du Dashboard
kubectl get pods -n kubernetes-dashboard
# Vérifier les services du Dashboard
kubectl get svc -n kubernetes-dashboard

cat > dashboard-admin.yaml << 'EOF'
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard
EOF

# Créer le ServiceAccount admin et son ClusterRoleBinding
kubectl apply -f dashboard-admin.yaml

cat > dashboard-ingress.yaml << 'EOF'
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
  annotations:
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  ingressClassName: nginx
  rules:
  - host: dashboard.xsel-ci.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: kubernetes-dashboard
            port:
              number: 443
EOF

# Exposer le Dashboard via NGINX Ingress
kubectl apply -f dashboard-ingress.yaml

### 11.4 — Obtenir le token d'accès d’accès

# Créer un token pour l'utilisateur admin
# Générer un token d'accès admin valable 10 ans
kubectl -n kubernetes-dashboard create token admin-user --duration=87600h
# Tester l'accès
# Tester l'accès au Dashboard via HAProxy
curl -k -H "Host: dashboard.xsel-ci.com" https://192.168.0.254
# Sur votre Mac
# Éditer le fichier hosts local pour résoudre le domaine sans DNS public
sudo vi /etc/hosts
# Ajouter cette ligne :
95.111.238.94 dashboard.xsel-ci.com

# Puis dans votre navigateur :
# https://dashboard.xsel-ci.com

# Afficher les nœuds du cluster et leur statut
kubectl get nodes
# Lister tous les pods de tous les namespaces
kubectl get pods --all-namespaces
# Afficher les endpoints du cluster
kubectl cluster-info
kubectl get events --all-namespaces --sort-by='.lastTimesta
mp' | tail -20
kubectl logs -n kube-system <pod-name>
kubectl drain <node-name> --ignore-daemonsets --delete-empt
ydir-data
kubectl uncordon <node-name>
# Générer une commande de join fraîche pour les nouveaux workers
kubeadm token create --print-join-command
# Voir tous les roles par namespace
# Lister tous les Roles par namespace
kubectl get roles -A
# Voir tous les clusterroles
# Lister les ClusterRoles personnalisés (hors système)
kubectl get clusterroles | grep -v "system:"
# Voir les rolebindings
# Lister tous les RoleBindings
kubectl get rolebindings -A
# Voir les clusterrolebindings
# Lister les ClusterRoleBindings personnalisés
kubectl get clusterrolebindings | grep -v "system:"
# Détail d'un role spécifique
kubectl describe role <nom-role> -n <namespace>
# Détail d'un clusterrole
kubectl describe clusterrole <nom-clusterrole>
# Vérifier les permissions d'un utilisateur/serviceaccount
kubectl auth can-i --list --as=system:serviceaccount:<names
pace>:<serviceaccount>
# Vérifier une permission spécifique
kubectl auth can-i get pods --as=system:serviceaccount:dev:
default -n dev

# Sur DEVNODE-01
# Se connecter à DEVNODE-01 via SSH
ssh root@207.180.196.59
# Arrêter le pare-feu
systemctl stop firewalld
# Démarrer le pare-feu
systemctl start firewalld
# Activer le pare-feu au démarrage
systemctl enable firewalld
# Vérifier l'état du pare-feu
systemctl status firewalld
Contactez l'administrateur WireGuard avec ces informations:

# Afficher les 100 dernières lignes de logs du kubelet
journalctl -u kubelet -n 100 --no-pager
# Vérifier l'état des pods Calico
kubectl get pods -n kube-system | grep calico
# Inspecter les logs d'un pod Calico spécifique
kubectl logs -n kube-system <calico-pod-name>
# Redémarrer containerd d'abord
# Redémarrer containerd
systemctl restart containerd
echo "Containerd redémarré, attente de 5 secondes..."
sleep 5
# Redémarrer kubelet après containerd
systemctl restart kubelet
echo "Kubelet redémarré, attente de 15 secondes..."
sleep 15
# Vérifier s'il y a encore des erreurs CNI
# Vérifier les erreurs CNI récentes dans les logs kubelet
journalctl -u kubelet -n 5 --no-pager | grep -i cni

# Afficher les événements et la configuration du pod en erreur
kubectl describe pod <pod-name>
# Afficher les logs du pod en erreur
kubectl logs <pod-name>

Cluster physique XSEL
  ├── tools         ← outils DevOps (Harbor, Jenkins…)
  ├── monitoring    ← stack monitoring (Prometheus, Grafana, Loki)
  ├── devmysql      ← bases de données MySQL
  └── devpostgresql ← bases de données PostgreSQL

cat > /root/k8s-xsel/namespaces.yaml << 'EOF'
---
apiVersion: v1
kind: Namespace
metadata:
  name: tools
  labels:
    name: tools
    type: services
---
apiVersion: v1
kind: Namespace
metadata:
  name: monitoring
  labels:
    name: monitoring
    type: services
---
apiVersion: v1
kind: Namespace
metadata:
  name: devmysql
  labels:
    name: devmysql
    type: databases
---
apiVersion: v1
kind: Namespace
metadata:
  name: devpostgresql
  labels:
    name: devpostgresql
    type: databases
EOF

# Créer les namespaces infrastructure dans le cluster
kubectl apply -f namespaces.yaml
# Vérifier que les namespaces ont bien été créés
kubectl get namespaces

cat > /root/k8s-xsel/resource-quotas.yaml << 'EOF'
---
# TOOLS — Harbor + GitLab + Jenkins
apiVersion: v1
kind: ResourceQuota
metadata:
  name: tools-quota
  namespace: tools
spec:
  hard:
    requests.cpu: "8"
    requests.memory: 20Gi
    limits.cpu: "24"
    limits.memory: 48Gi
    pods: "50"
    services: "50"
    persistentvolumeclaims: "20"
---
# MONITORING — Prometheus + Grafana + AlertManager + Loki + Promtail + PMM
# ⚠️ requests.cpu réduit à 2 car les workers sont saturés par PXC/ProxySQL/Longhorn
# Calcul réel :
#   Prometheus      : 200m
#   AlertManager    : 50m (min 64Mi memory imposé par LimitRange)
#   Grafana         : 150m (3 containers × 50m)
#   Node Exporter   : 4 × 50m = 200m (1 par nœud)
#   Kube State Met. : 50m
#   PMM             : 50m
#   Loki            : 100m
#   Promtail        : 4 × 50m = 200m (1 par nœud)
#   Total           : ~1000m → quota à 2 avec marge
# ⚠️ Si les workers sont à > 85% de CPU requests avant installation :
#    réduire les requests PXC (600m→200m) et ProxySQL (600m→100m) d'abord
#    (voir §22.6 Prérequis CPU)
apiVersion: v1
kind: ResourceQuota
metadata:
  name: monitoring-quota
  namespace: monitoring
spec:
  hard:
    requests.cpu: "2"
    requests.memory: 16Gi
    limits.cpu: "16"
    limits.memory: 32Gi
    pods: "30"
    services: "20"
    persistentvolumeclaims: "15"
---
# DEVMYSQL — PXC x3 + ProxySQL x3 + operator + sidecars logcollector
# requests.cpu : 3 PXC (600m×3) + 3 ProxySQL (600m×3) + operator (100m) = ~3700m → quota 6
# limits.cpu   : 3 PXC (1×3=3) + 3 ProxySQL (1×3=3) + operator (200m) + logcollector sidecars (~200m×6=1.2) = ~7.4
# ⚠️ Ne pas mettre limits.cpu < 16 : les sidecars Percona (logcollector, pxc-monit)
#    s'ajoutent aux limits des containers principaux et saturent rapidement le quota
apiVersion: v1
kind: ResourceQuota
metadata:
  name: devmysql-quota
  namespace: devmysql
spec:
  hard:
    requests.cpu: "6"
    requests.memory: 12Gi
    limits.cpu: "16"
    limits.memory: 24Gi
    pods: "20"
    services: "15"
    persistentvolumeclaims: "15"
---
# DEVPOSTGRESQL — PG x3 + PgBouncer x3 + operator + sidecars
# requests.cpu : même logique que devmysql → quota 6
# limits.cpu   : même logique que devmysql → quota 16
# ⚠️ Ne pas mettre limits.cpu < 16 : les sidecars Percona s'ajoutent aux limits principales
apiVersion: v1
kind: ResourceQuota
metadata:
  name: devpostgresql-quota
  namespace: devpostgresql
spec:
  hard:
    requests.cpu: "6"
    requests.memory: 12Gi
    limits.cpu: "16"
    limits.memory: 24Gi
    pods: "20"
    services: "15"
    persistentvolumeclaims: "15"
EOF

# Appliquer les quotas de ressources sur les namespaces
kubectl apply -f resource-quotas.yaml
# Vérifier les quotas appliqués sur tous les namespaces
kubectl get resourcequota -A

cat > /root/k8s-xsel/limit-ranges.yaml << 'EOF'
---
# TOOLS — min 10m/64Mi pour cert-manager cm-acme-http-solver
apiVersion: v1
kind: LimitRange
metadata:
  name: tools-limit-range
  namespace: tools
spec:
  limits:
  - type: Container
    max:
      cpu: "4"
      memory: 8Gi
    min:
      cpu: "10m"
      memory: 64Mi
    default:
      cpu: "500m"
      memory: 512Mi
    defaultRequest:
      cpu: "50m"
      memory: 128Mi
---
# MONITORING
apiVersion: v1
kind: LimitRange
metadata:
  name: monitoring-limit-range
  namespace: monitoring
spec:
  limits:
  - type: Container
    max:
      cpu: "4"
      memory: 8Gi
    min:
      cpu: "10m"
      memory: 64Mi
    default:
      cpu: "500m"
      memory: 1Gi
    defaultRequest:
      cpu: "50m"
      memory: 128Mi
---
# DEVMYSQL
# ⚠️ min: 20Mi — pxc-operator demande 20Mi par défaut dans ses charts Helm
# ⚠️ default/defaultRequest définis explicitement pour éviter que Kubernetes
#    n'injecte max (8Gi) comme limit par défaut → explose le quota immédiatement
# ⚠️ Les pods PXC/ProxySQL ont leurs propres limits dans le CR (2G/1CPU)
#    donc le LimitRange ne leur injecte rien — il ne s'applique qu'aux
#    containers sans limits déclarées (sidecars légers, init containers)
apiVersion: v1
kind: LimitRange
metadata:
  name: devmysql-limit-range
  namespace: devmysql
spec:
  limits:
  - type: Container
    max:
      cpu: "4"
      memory: 8Gi
    min:
      cpu: "10m"
      memory: 20Mi
    default:
      cpu: "500m"
      memory: 256Mi
    defaultRequest:
      cpu: "100m"
      memory: 128Mi
---
# DEVPOSTGRESQL — mêmes contraintes que devmysql
# ⚠️ min: 20Mi — pg-operator demande 20Mi par défaut dans ses charts Helm
apiVersion: v1
kind: LimitRange
metadata:
  name: devpostgresql-limit-range
  namespace: devpostgresql
spec:
  limits:
  - type: Container
    max:
      cpu: "4"
      memory: 8Gi
    min:
      cpu: "10m"
      memory: 20Mi
    default:
      cpu: "500m"
      memory: 256Mi
    defaultRequest:
      cpu: "100m"
      memory: 128Mi
EOF

# Appliquer les LimitRanges sur les namespaces
kubectl apply -f limit-ranges.yaml
# Vérifier les LimitRanges appliquées
kubectl get limitrange -A

# Afficher la consommation CPU/RAM de chaque nœud
kubectl top nodes
# Afficher les ressources allouées sur DEVNODE-01
kubectl describe node xsel-devnode-01 | grep -A6 "Allocated resources"
# Afficher les ressources allouées sur DEVNODE-02
kubectl describe node xsel-devnode-02 | grep -A6 "Allocated resources"

# Diagnostiquer pourquoi un pod est bloqué en Pending
kubectl describe pod <pod-name> -n <namespace> | grep -A10 Events

cat > /root/k8s-xsel/network-policies.yaml << 'EOF'
---
# TOOLS — ingress depuis ingress-nginx et monitoring uniquement
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: tools-network-policy
  namespace: tools
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: ingress-nginx
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: monitoring
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: tools
  egress:
  - {}
---
# MONITORING — accès à tous les namespaces pour scraper les métriques
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: monitoring-network-policy
  namespace: monitoring
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: ingress-nginx
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: monitoring
  egress:
  - {}
---
# DEVMYSQL — isolation BDD
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: devmysql-network-policy
  namespace: devmysql
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: devmysql
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: ingress-nginx
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: monitoring
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: tools
---
# DEVPOSTGRESQL — isolation BDD
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: devpostgresql-network-policy
  namespace: devpostgresql
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: devpostgresql
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: ingress-nginx
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: monitoring
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: tools
EOF

# Appliquer les NetworkPolicies d'isolation inter-namespaces
kubectl apply -f network-policies.yaml
# Vérifier les NetworkPolicies sur tous les namespaces
kubectl get networkpolicy -A

cat > /root/k8s-xsel/rbac.yaml << 'RBACEOF'
---
# ServiceAccount tools — lecture seule
apiVersion: v1
kind: ServiceAccount
metadata:
  name: tools-sa
  namespace: tools
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: tools-role
  namespace: tools
rules:
- apiGroups: [""]
  resources: ["pods", "services", "configmaps", "secrets"]
  verbs: ["get", "list", "watch"]
- apiGroups: ["apps"]
  resources: ["deployments", "statefulsets"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: tools-rolebinding
  namespace: tools
subjects:
- kind: ServiceAccount
  name: tools-sa
  namespace: tools
roleRef:
  kind: Role
  name: tools-role
  apiGroup: rbac.authorization.k8s.io
---
# ServiceAccount monitoring — lecture cluster-wide pour Prometheus
apiVersion: v1
kind: ServiceAccount
metadata:
  name: monitoring-sa
  namespace: monitoring
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: monitoring-cluster-role
rules:
- apiGroups: [""]
  resources: ["nodes", "pods", "services", "endpoints", "namespaces"]
  verbs: ["get", "list", "watch"]
- apiGroups: ["apps"]
  resources: ["deployments", "statefulsets", "daemonsets"]
  verbs: ["get", "list", "watch"]
- apiGroups: ["extensions", "networking.k8s.io"]
  resources: ["ingresses"]
  verbs: ["get", "list", "watch"]
- nonResourceURLs: ["/metrics"]
  verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: monitoring-cluster-rolebinding
subjects:
- kind: ServiceAccount
  name: monitoring-sa
  namespace: monitoring
roleRef:
  kind: ClusterRole
  name: monitoring-cluster-role
  apiGroup: rbac.authorization.k8s.io
---
# ServiceAccount databases — accès restreint
apiVersion: v1
kind: ServiceAccount
metadata:
  name: databases-sa
  namespace: devmysql
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: databases-role
  namespace: devmysql
rules:
- apiGroups: [""]
  resources: ["pods", "services", "configmaps"]
  verbs: ["get", "list", "watch"]
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get"]
RBACEOF

# Appliquer les règles RBAC (ServiceAccounts, Roles, Bindings)
kubectl apply -f /root/k8s-xsel/rbac.yaml
# Lister tous les Roles par namespace
kubectl get roles -A
# Lister les ClusterRoles personnalisés (hors système)
kubectl get clusterroles | grep -v "system:"

# Installer NFS
# Installer les utilitaires NFS (serveur et client)
dnf install -y nfs-utils

# Créer les répertoires
# Créer l'arborescence des répertoires NFS par service
mkdir -p /srv/nfs/kubernetes/{prometheus,grafana,loki,gitlab,jenkins,registry,certmanager}
# Autoriser l'accès en lecture/écriture à tous les pods NFS
chmod -R 777 /srv/nfs/kubernetes

# Configurer les exports
cat > /etc/exports << 'EOF'
/srv/nfs/kubernetes 192.168.0.0/16(rw,sync,no_subtree_check,no_root_squash)
EOF

# Démarrer NFS
# Démarrer et activer le serveur NFS au démarrage
systemctl enable --now nfs-server
# Publier les exports NFS définis dans /etc/exports
exportfs -rav

# Vérifier
# Vérifier les exports NFS disponibles localement
showmount -e localhost

# Installer les utilitaires NFS (serveur et client)
dnf install -y nfs-utils
# Vérifier les exports NFS disponibles depuis le serveur master-01
showmount -e 192.168.0.1

# Se positionner dans le répertoire de travail
cd /root/k8s-xsel
cat > /root/k8s-xsel/nfs-all.yaml << 'EOF'
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: nfs-provisioner
  namespace: nfs-provisioner
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: nfs-provisioner-role
rules:
- apiGroups: [""]
  resources: ["persistentvolumes"]
  verbs: ["get","list","watch","create","delete"]
- apiGroups: [""]
  resources: ["persistentvolumeclaims"]
  verbs: ["get","list","watch","update"]
- apiGroups: ["storage.k8s.io"]
  resources: ["storageclasses"]
  verbs: ["get","list","watch"]
- apiGroups: [""]
  resources: ["events"]
  verbs: ["create","update","patch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: nfs-provisioner-role-endpoints
  namespace: nfs-provisioner
rules:
- apiGroups: [""]
  resources: ["endpoints"]
  verbs: ["get","list","watch","create","update","patch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: nfs-provisioner-binding
subjects:
- kind: ServiceAccount
  name: nfs-provisioner
  namespace: nfs-provisioner
roleRef:
  kind: ClusterRole
  name: nfs-provisioner-role
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: nfs-provisioner-binding-endpoints
  namespace: nfs-provisioner
subjects:
- kind: ServiceAccount
  name: nfs-provisioner
  namespace: nfs-provisioner
roleRef:
  kind: Role
  name: nfs-provisioner-role-endpoints
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nfs-provisioner
  namespace: nfs-provisioner
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nfs-provisioner
  template:
    metadata:
      labels:
        app: nfs-provisioner
    spec:
      serviceAccountName: nfs-provisioner
      containers:
      - name: nfs-provisioner
        image: registry.k8s.io/sig-storage/nfs-subdir-external-provisioner:v4.0.2
        env:
        - name: PROVISIONER_NAME
          value: nfs.io/nfs-provisioner
        - name: NFS_SERVER
          value: "192.168.0.1"
        - name: NFS_PATH
          value: "/srv/nfs/kubernetes"
        volumeMounts:
        - name: nfs-root
          mountPath: /persistentvolumes
      volumes:
      - name: nfs-root
        nfs:
          server: 192.168.0.1
          path: /srv/nfs/kubernetes
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-storage
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: nfs.io/nfs-provisioner
parameters:
  archiveOnDelete: "false"
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-prometheus
provisioner: nfs.io/nfs-provisioner
parameters:
  pathPattern: "prometheus/{.PVC.namespace}/{.PVC.name}"
  archiveOnDelete: "false"
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-grafana
provisioner: nfs.io/nfs-provisioner
parameters:
  pathPattern: "grafana/{.PVC.namespace}/{.PVC.name}"
  archiveOnDelete: "false"
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-loki
provisioner: nfs.io/nfs-provisioner
parameters:
  pathPattern: "loki/{.PVC.namespace}/{.PVC.name}"
  archiveOnDelete: "false"
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-gitlab
provisioner: nfs.io/nfs-provisioner
parameters:
  pathPattern: "gitlab/{.PVC.namespace}/{.PVC.name}"
  archiveOnDelete: "false"
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-jenkins
provisioner: nfs.io/nfs-provisioner
parameters:
  pathPattern: "jenkins/{.PVC.namespace}/{.PVC.name}"
  archiveOnDelete: "false"
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-registry
provisioner: nfs.io/nfs-provisioner
parameters:
  pathPattern: "registry/{.PVC.namespace}/{.PVC.name}"
  archiveOnDelete: "false"
EOF

# ⚠️ Créer le namespace AVANT d'appliquer le manifeste
# Créer le namespace dédié au provisionneur NFS
kubectl create namespace nfs-provisioner
# Déployer le provisionneur NFS et les StorageClasses
kubectl apply -f /root/k8s-xsel/nfs-all.yaml

# Attendre le démarrage
sleep 15
# Vérifier que le pod NFS provisioner est en Running
kubectl get pods -n nfs-provisioner
# Lister les StorageClasses disponibles dans le cluster
kubectl get storageclass

kubectl apply -f - << 'EOF'
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: test-pvc
  namespace: default
spec:
  accessModes:
  - ReadWriteMany
  storageClassName: nfs-storage
  resources:
    requests:
      storage: 1Gi
EOF

sleep 10
# Vérifier que le PVC de test est en état Bound
kubectl get pvc test-pvc

# Nettoyage
# Supprimer le PVC de test après validation
kubectl delete pvc test-pvc -n default

echo "=== NFS Server ===" && systemctl status nfs-server | grep Active
echo "=== Exports ===" && exportfs -v
echo "=== Provisioner ===" && kubectl get pods -n nfs-provisioner
echo "=== StorageClasses ===" && kubectl get storageclass
echo "=== Dossiers ===" && ls -la /srv/nfs/kubernetes/

=== NFS Server ===
Active: active (exited)   ← normal sur systemd, le service délègue au kernel

=== Exports ===
/srv/nfs/kubernetes 192.168.0.0/16(sync,wdelay,hide,no_subtree_check,rw,no_root_squash)

=== Provisioner ===
nfs-provisioner-6d55b9967d-sntrs   1/1 Running ✅

=== StorageClasses ===
nfs-storage (default)   nfs.io/nfs-provisioner ✅
nfs-prometheus          nfs.io/nfs-provisioner ✅
nfs-grafana             nfs.io/nfs-provisioner ✅
nfs-loki                nfs.io/nfs-provisioner ✅
nfs-gitlab              nfs.io/nfs-provisioner ✅
nfs-jenkins             nfs.io/nfs-provisioner ✅
nfs-registry            nfs.io/nfs-provisioner ✅

=== Dossiers ===
certmanager/   gitlab/   grafana/   jenkins/
loki/          prometheus/   registry/
devmysql-*/    (données Percona MySQL existantes)

Pod (ex: Grafana)
      │
      ▼
Volume Longhorn "grafana-pvc"
      │
      ├── Replica 1 → xsel-devnode-01  /var/lib/longhorn/
      └── Replica 2 → xsel-devnode-02  /var/lib/longhorn/

# Installer open-iscsi (requis par Longhorn)
# Installer le client iSCSI requis par Longhorn
dnf install -y iscsi-initiator-utils

# Démarrer et activer le service
# Démarrer et activer le daemon iSCSI au démarrage
systemctl enable --now iscsid

# Vérifier
# Vérifier que le service iSCSI est actif
systemctl status iscsid

# Lancer le script de vérification des prérequis Longhorn sur tous les nœuds
curl -sSfL https://raw.githubusercontent.com/longhorn/longhorn/v1.6.0/scripts/environment_check.sh | bash

[INFO]  Required dependencies 'kubectl jq mktemp sort printf' are installed.
[INFO]  All nodes have unique hostnames.
[INFO]  All longhorn-environment-check pods are ready (2/2).
[INFO]  MountPropagation is enabled
[INFO]  Checking kernel release...
[INFO]  Checking iscsid...
[INFO]  Checking multipathd...
[INFO]  Checking packages...
[INFO]  Checking nfs client...
[INFO]  Cleanup completed.

# Ajouter le repo Helm officiel Longhorn
helm repo add longhorn https://charts.longhorn.io
# Mettre à jour le cache des repos Helm
helm repo update

# Vérifier
# Vérifier les versions disponibles de Longhorn
helm search repo longhorn/longhorn

# Créer le namespace pour Longhorn
kubectl create namespace longhorn-system

helm install longhorn longhorn/longhorn \
  --namespace longhorn-system \
  --version 1.6.2 \
  --set defaultSettings.defaultReplicaCount=2 \
  --set defaultSettings.storageMinimalAvailablePercentage=10 \
  --set ingress.enabled=true \
  --set ingress.ingressClassName=nginx \
  --set ingress.host=longhorn.xselcloud.com \
  --wait \
  --timeout 10m

# Vérifier que tous les pods Longhorn sont en Running
kubectl get pods -n longhorn-system

NAME                                    READY   STATUS    NODE
csi-attacher-*                          1/1     Running   devnode-01/02
csi-provisioner-*                       1/1     Running   devnode-01/02
csi-resizer-*                           1/1     Running   devnode-01/02
csi-snapshotter-*                       1/1     Running   devnode-01/02
engine-image-ei-b0369a5d-*             1/1     Running   devnode-01
engine-image-ei-b0369a5d-*             1/1     Running   devnode-02
instance-manager-*                      1/1     Running   devnode-01
instance-manager-*                      1/1     Running   devnode-02
longhorn-csi-plugin-*                   3/3     Running   devnode-01
longhorn-csi-plugin-*                   3/3     Running   devnode-02
longhorn-driver-deployer-*              1/1     Running   devnode-01
longhorn-manager-*                      1/1     Running   devnode-01
longhorn-manager-*                      1/1     Running   devnode-02
longhorn-ui-*                           1/1     Running   devnode-01
longhorn-ui-*                           1/1     Running   devnode-02

# Vérifier les nodes Longhorn
# Vérifier que les workers sont bien enregistrés dans Longhorn
kubectl get nodes.longhorn.io -n longhorn-system

NAME              READY   ALLOWSCHEDULING   SCHEDULABLE
xsel-devnode-01   True    true              True
xsel-devnode-02   True    true              True

# Retirer le statut "default" de nfs-storage
kubectl patch storageclass nfs-storage \
  -p '{"metadata": {"annotations": {"storageclass.kubernetes.io/is-default-class": "false"}}}'

# Vérifier — seul longhorn doit avoir (default)
# Lister les StorageClasses disponibles dans le cluster
kubectl get storageclass

NAME                    PROVISIONER               RECLAIMPOLICY
longhorn (default)      driver.longhorn.io        Delete
longhorn-static         driver.longhorn.io        Delete
nfs-storage             nfs.io/nfs-provisioner    Delete
nfs-grafana             nfs.io/nfs-provisioner    Delete
nfs-prometheus          nfs.io/nfs-provisioner    Delete
...

# Option 1 — Via Ingress (DNS configuré)
# https://longhorn.xselcloud.com

# Option 2 — Port-forward (sans DNS)
kubectl port-forward svc/longhorn-frontend \
  -n longhorn-system 8080:80 &
# http://localhost:8080

✅ open-iscsi          : installé sur tous les nodes (dnf install iscsi-initiator-utils)
✅ Longhorn v1.6.2     : installé dans longhorn-system
✅ StorageClass        : longhorn (default)
✅ Réplication         : 2 replicas par volume (devnode-01 + devnode-02)
✅ Dashboard           : https://longhorn.xselcloud.com
✅ Cohabitation NFS    : nfs-storage (RWX) reste disponible (non-default)

Cluster physique XSEL
  ├── vcluster-dev     ← Kubernetes DEV     (longhorn)
  ├── vcluster-test    ← Kubernetes TEST    (longhorn)
  ├── vcluster-staging ← Kubernetes STAGING (longhorn)
  └── vcluster-prod    ← Kubernetes PROD    (longhorn)

Navigateur → demo-dev.xsel-ci.com
    → HAProxy (95.111.238.94:443)
    → NGINX Ingress physique (devnode-01/02:30443)
    → Pod nginx-demo (dans vcluster-dev)

if ! command -v vcluster &>/dev/null; then
  mkdir -p /root/k8s-xsel/vcluster
  curl -L -o /root/k8s-xsel/vcluster/vcluster-cli \
    "https://github.com/loft-sh/vcluster/releases/latest/download/vcluster-linux-amd64"
  chmod +x /root/k8s-xsel/vcluster/vcluster-cli
  ln -sf /root/k8s-xsel/vcluster/vcluster-cli /usr/local/bin/vcluster
fi
# Vérifier la version du CLI vCluster installé
vcluster version
# Résultat : vcluster version 0.34.0

mkdir -p /root/k8s-xsel/vcluster

cat > /root/k8s-xsel/vcluster/values.yaml << 'EOF'
sync:
  toHost:
    ingresses:
      enabled: true
controlPlane:
  statefulSet:
    persistence:
      volumeClaim:
        enabled: true
        storageClass: "longhorn"
        size: 5Gi
        retentionPolicy: Retain
        accessModes: ["ReadWriteOnce"]
EOF

echo "✅ values.yaml créé"

for env in dev test staging prod; do
  kubectl create namespace vcluster-$env --dry-run=client -o yaml | kubectl apply -f -
  vcluster create vcluster-$env \
    --namespace vcluster-$env \
    --connect=false \
    -f /root/k8s-xsel/vcluster/values.yaml
  echo "✅ vcluster-$env créé"
done

# Lister tous les vClusters déployés dans le cluster physique
vcluster list
# Vérifier que les PVCs Longhorn des vClusters sont en état Bound
kubectl get pvc -A | grep vcluster

NAME             | NAMESPACE        | STATUS  | VERSION
vcluster-dev     | vcluster-dev     | Running | 0.34.0
vcluster-test    | vcluster-test    | Running | 0.34.0
vcluster-staging | vcluster-staging | Running | 0.34.0
vcluster-prod    | vcluster-prod    | Running | 0.34.0

NAMESPACE          PVC                       STATUS   STORAGECLASS
vcluster-dev       data-vcluster-dev-0       Bound    longhorn     ✅
vcluster-test      data-vcluster-test-0      Bound    longhorn     ✅
vcluster-staging   data-vcluster-staging-0   Bound    longhorn     ✅
vcluster-prod      data-vcluster-prod-0      Bound    longhorn     ✅

mkdir -p /root/k8s-xsel/vcluster/apps

# DEV — bleu
cat > /root/k8s-xsel/vcluster/apps/nginx-dev.yaml << 'EOF'
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-index
  namespace: default
data:
  index.html: |
    <!DOCTYPE html>
    <html>
    <head>
      <meta charset="UTF-8">
      <title>XSEL — DEV</title>
      <style>
        body {
          margin: 0;
          font-family: 'Segoe UI', sans-serif;
          background: #0f172a;
          color: #f1f5f9;
          display: flex;
          align-items: center;
          justify-content: center;
          height: 100vh;
        }
        .card {
          background: #1e293b;
          border: 2px solid #3B82F6;
          border-radius: 12px;
          padding: 48px 64px;
          text-align: center;
          box-shadow: 0 0 40px #3B82F644;
        }
        .env-badge {
          background: #3B82F6;
          color: #fff;
          font-size: 14px;
          font-weight: 700;
          letter-spacing: 3px;
          padding: 6px 18px;
          border-radius: 20px;
          display: inline-block;
          margin-bottom: 24px;
        }
        h1 { font-size: 48px; margin: 0 0 8px; }
        p  { color: #94a3b8; margin: 4px 0; font-size: 14px; }
      </style>
    </head>
    <body>
      <div class="card">
        <div class="env-badge">DEV</div>
        <h1>XSEL Cloud</h1>
        <p>vCluster · Kubernetes virtuel</p>
        <p>Environnement : <strong style="color:#3B82F6">DEV</strong></p>
      </div>
    </body>
    </html>
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-demo
  namespace: default
  labels:
    app: nginx-demo
    env: dev
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-demo
  template:
    metadata:
      labels:
        app: nginx-demo
        env: dev
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
        volumeMounts:
        - name: html
          mountPath: /usr/share/nginx/html
      volumes:
      - name: html
        configMap:
          name: nginx-index
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-demo
  namespace: default
spec:
  selector:
    app: nginx-demo
  ports:
  - port: 80
    targetPort: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-demo
  namespace: default
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: demo-dev.xsel-ci.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-demo
            port:
              number: 80
EOF
echo "✅ Manifest nginx-dev.yaml créé"

# PROD — vert
cat > /root/k8s-xsel/vcluster/apps/nginx-prod.yaml << 'EOF'
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-index
  namespace: default
data:
  index.html: |
    <!DOCTYPE html>
    <html>
    <head>
      <meta charset="UTF-8">
      <title>XSEL — PROD</title>
      <style>
        body {
          margin: 0;
          font-family: 'Segoe UI', sans-serif;
          background: #0f172a;
          color: #f1f5f9;
          display: flex;
          align-items: center;
          justify-content: center;
          height: 100vh;
        }
        .card {
          background: #1e293b;
          border: 2px solid #10B981;
          border-radius: 12px;
          padding: 48px 64px;
          text-align: center;
          box-shadow: 0 0 40px #10B98144;
        }
        .env-badge {
          background: #10B981;
          color: #fff;
          font-size: 14px;
          font-weight: 700;
          letter-spacing: 3px;
          padding: 6px 18px;
          border-radius: 20px;
          display: inline-block;
          margin-bottom: 24px;
        }
        h1 { font-size: 48px; margin: 0 0 8px; }
        p  { color: #94a3b8; margin: 4px 0; font-size: 14px; }
      </style>
    </head>
    <body>
      <div class="card">
        <div class="env-badge">PROD</div>
        <h1>XSEL Cloud</h1>
        <p>vCluster · Kubernetes virtuel</p>
        <p>Environnement : <strong style="color:#10B981">PROD</strong></p>
      </div>
    </body>
    </html>
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-demo
  namespace: default
  labels:
    app: nginx-demo
    env: prod
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-demo
  template:
    metadata:
      labels:
        app: nginx-demo
        env: prod
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
        volumeMounts:
        - name: html
          mountPath: /usr/share/nginx/html
      volumes:
      - name: html
        configMap:
          name: nginx-index
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-demo
  namespace: default
spec:
  selector:
    app: nginx-demo
  ports:
  - port: 80
    targetPort: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-demo
  namespace: default
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: prod-dev.xsel-ci.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-demo
            port:
              number: 80
EOF
echo "✅ Manifest nginx-prod.yaml créé"

# DEV
vcluster connect vcluster-dev --namespace vcluster-dev -- \
  kubectl apply -f /root/k8s-xsel/vcluster/apps/nginx-dev.yaml
echo "✅ nginx déployé dans vcluster-dev"

# PROD
vcluster connect vcluster-prod --namespace vcluster-prod -- \
  kubectl apply -f /root/k8s-xsel/vcluster/apps/nginx-prod.yaml
echo "✅ nginx déployé dans vcluster-prod"

# Vérifier depuis l'intérieur de chaque vCluster
for env in dev prod; do
  echo "=== vcluster-$env ==="
  vcluster connect vcluster-$env --namespace vcluster-$env -- \
    kubectl get pods,svc,ingress -n default
done

=== vcluster-dev ===
NAME                            READY   STATUS    RESTARTS
pod/nginx-demo-<hash>           1/1     Running   0

NAME                 TYPE        CLUSTER-IP   PORT(S)
service/nginx-demo   ClusterIP   10.x.x.x     80/TCP

NAME                                                    CLASS   HOSTS
ingress.networking.k8s.io/nginx-demo                    nginx   demo-dev.xsel-ci.com

=== vcluster-prod ===
NAME                            READY   STATUS    RESTARTS
pod/nginx-demo-<hash>           1/1     Running   0

NAME                 TYPE        CLUSTER-IP   PORT(S)
service/nginx-demo   ClusterIP   10.x.x.x     80/TCP

NAME                                                    CLASS   HOSTS
ingress.networking.k8s.io/nginx-demo                    nginx   prod-dev.xsel-ci.com

# Vérifier que les Ingress sont bien synchronisés dans le cluster physique
# Vérifier la synchronisation des Ingress depuis les vClusters vers le cluster physique
kubectl get ingress -A | grep vcluster
# Résultat attendu :
# vcluster-dev    nginx-demo-x-default-x-vcluster-dev    nginx   demo-dev.xsel-ci.com    192.168.1.1
# vcluster-prod   nginx-demo-x-default-x-vcluster-prod   nginx   prod-dev.xsel-ci.com    192.168.1.1

✅ vcluster-dev    : Running — longhorn
✅ vcluster-test   : Running — longhorn
✅ vcluster-staging: Running — longhorn
✅ vcluster-prod   : Running — longhorn
✅ Sync Ingress    : activée (sync.toHost.ingresses.enabled: true)
✅ nginx-demo DEV  : http://demo-dev.xsel-ci.com  (bleu)
✅ nginx-demo PROD : http://prod-dev.xsel-ci.com  (vert)

# Créer le namespace pour cert-manager
kubectl create namespace cert-manager

# Déployer cert-manager v1.14.0 avec tous ses composants
kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.14.0/cert-manager.yaml

kubectl wait --for=condition=ready pod \
  -l app.kubernetes.io/instance=cert-manager \
  -n cert-manager --timeout=120s

# Vérifier les pods cert-manager (controller, cainjector, webhook)
kubectl get pods -n cert-manager

cat > /root/k8s-xsel/cert-manager-issuers.yaml << 'EOF'
---
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-staging
spec:
  acme:
    server: https://acme-staging-v02.api.letsencrypt.org/directory
    email: ton-email@xsel-services.com
    privateKeySecretRef:
      name: letsencrypt-staging-key
    solvers:
    - http01:
        ingress:
          ingressClassName: nginx
---
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: ton-email@xsel-services.com
    privateKeySecretRef:
      name: letsencrypt-prod-key
    solvers:
    - http01:
        ingress:
          ingressClassName: nginx
EOF

# Créer les ClusterIssuers Let's Encrypt (staging et production)
kubectl apply -f /root/k8s-xsel/cert-manager-issuers.yaml
# Vérifier que les ClusterIssuers sont en état READY: True
kubectl get clusterissuer

# Vérifier la propagation DNS
# Vérifier la propagation DNS du domaine de test via Google DNS
nslookup sgh24.xsel-ci.com 8.8.8.8
# Résultat attendu :
# Nom    : sgh24.xsel-ci.com
# Address: 95.111.238.94

# Créer un Certificate de test
cat > /root/k8s-xsel/test-cert.yaml << 'EOF'
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: test-cert
  namespace: default
spec:
  dnsNames:
  - sgh24.xsel-ci.com
  issuerRef:
    kind: ClusterIssuer
    name: letsencrypt-staging
  secretName: test-cert-tls
EOF

# Demander l'émission d'un certificat de test via Let's Encrypt staging
kubectl apply -f /root/k8s-xsel/test-cert.yaml

# Vérifier après 2 à 3 minutes
# Vérifier l'état de l'émission du certificat de test
kubectl describe certificate test-cert -n default | grep -A3 "Conditions"

echo "=== Pods Cert-Manager ===" && kubectl get pods -n cert-manager
echo "=== ClusterIssuers ===" && kubectl get clusterissuer
echo "=== Secrets TLS ===" && kubectl get secrets -A | grep tls

=== ClusterIssuers ===
NAME                  READY
letsencrypt-staging   True
letsencrypt-prod      True

metadata:
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"   # production
    # cert-manager.io/cluster-issuer: "letsencrypt-staging"  # tests
spec:
  tls:
  - hosts:
    - mon-service.xsel-services.com
    secretName: mon-service-tls

# Ajouter le repo Helm officiel Harbor
helm repo add harbor https://helm.goharbor.io
# Mettre à jour le cache des repos Helm
helm repo update

helm install harbor harbor/harbor \
  --namespace tools \
  --set expose.type=ingress \
  --set expose.ingress.hosts.core=registry.xsel-ci.com \
  --set expose.ingress.className=nginx \
  --set expose.ingress.annotations."nginx\.ingress\.kubernetes\.io/ssl-redirect"=false \
  --set expose.tls.certSource=auto \
  --set expose.tls.auto.commonName=registry.xsel-ci.com \
  --set externalURL=https://registry.xsel-ci.com \
  --set harborAdminPassword=XselHarbor2025! \
  --set persistence.persistentVolumeClaim.registry.storageClass=nfs-registry \
  --set persistence.persistentVolumeClaim.database.storageClass=nfs-storage \
  --set persistence.persistentVolumeClaim.redis.storageClass=nfs-storage

# Surveiller l'émission du certificat (2-5 min)
# Surveiller en temps réel l'émission du certificat TLS Harbor
kubectl get certificate -n tools -w

# Vérifier les challenges ACME
# Vérifier le challenge ACME HTTP-01 en cours
kubectl get challenges -n tools

# Vérifier la validité du certificat une fois émis
kubectl get secret harbor-tls -n tools -o jsonpath='{.data.tls\.crt}' | \
  base64 -d | openssl x509 -noout -dates -subject 2>/dev/null

# Vérifier que tous les pods Harbor sont en Running
kubectl get pods -n tools
# Vérifier les volumes persistants Harbor
kubectl get pvc -n tools
# Vérifier l'Ingress Harbor
kubectl get ingress -n tools
# Vérifier le statut du certificat TLS Harbor
kubectl get certificate -n tools

harbor-core        1/1 Running ✅
harbor-database    1/1 Running ✅
harbor-jobservice  1/1 Running ✅
harbor-portal      1/1 Running ✅
harbor-redis       1/1 Running ✅
harbor-registry    2/2 Running ✅
harbor-trivy       1/1 Running ✅

harbor-ingress   nginx   registry.xsel-ci.com   192.168.1.1   80, 443 ✅
Certificat TLS   READY: True ✅

# Forcer la réémission du certificat
# Supprimer le certificat existant pour forcer la réémission
kubectl delete certificate harbor-tls -n tools 2>/dev/null || true
# Supprimer le secret TLS associé
kubectl delete secret harbor-tls -n tools 2>/dev/null || true

# Recréer
cat << 'EOF' | kubectl apply -f -
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: harbor-tls
  namespace: tools
spec:
  secretName: harbor-tls
  dnsNames:
  - registry.xsel-ci.com
  issuerRef:
    name: letsencrypt-prod
    kind: ClusterIssuer
EOF

# Surveiller en temps réel l'émission du certificat TLS Harbor
kubectl get certificate -n tools -w

URL   : https://registry.xsel-ci.com
Login : admin
Pass  : XselHarbor2025!

# Créer le namespace dédié à MySQL
kubectl create namespace devmysql

# Ajouter le repo Helm officiel Percona
helm repo add percona https://percona.github.io/percona-helm-charts/
# Mettre à jour le cache des repos Helm
helm repo update

# Créer le fichier de values pour surcharger la request mémoire par défaut (20Mi → 64Mi)
# ⚠️ Sans ce fichier, pxc-operator demande 20Mi ce qui est rejeté par le LimitRange
#    devmysql (min: 20Mi). On monte à 64Mi pour une marge opérationnelle correcte.
cat > /root/k8s-xsel/pxc-operator-values.yaml << 'EOF'
resources:
  requests:
    memory: "64Mi"
    cpu: "100m"
  limits:
    memory: "500Mi"
    cpu: "200m"
EOF

# Installer pxc-operator avec les values personnalisées
helm install pxc-operator percona/pxc-operator \
  --namespace devmysql \
  --values /root/k8s-xsel/pxc-operator-values.yaml

# Vérifier que le pod opérateur démarre correctement
kubectl get pods -n devmysql -l app.kubernetes.io/name=pxc-operator -w

helm install pxc-cluster percona/pxc-db \
  --namespace devmysql \
  --set pxc.size=3 \
  --set pxc.antiAffinityTopologyKey="none" \
  --set haproxy.enabled=false \
  --set proxysql.enabled=true \
  --set proxysql.size=3 \
  --set proxysql.antiAffinityTopologyKey="none" \
  --set pxc.persistence.storageClass=nfs-storage \
  --set pxc.persistence.size=20Gi \
  --set pxc.resources.requests.memory="1G" \
  --set pxc.resources.requests.cpu="600m" \
  --set pxc.resources.limits.memory="2G" \
  --set pxc.resources.limits.cpu="1" \
  --set proxysql.resources.requests.memory="1G" \
  --set proxysql.resources.requests.cpu="600m" \
  --set proxysql.resources.limits.memory="2G" \
  --set proxysql.resources.limits.cpu="1"

# Surveiller en temps réel le démarrage des pods (3-5 min)
watch kubectl get pods -n devmysql

kubectl patch pxc pxc-cluster-pxc-db -n devmysql --type=merge -p '{
  "spec": {
    "proxysql": {
      "configuration": "datadir=\"/var/lib/proxysql\"\n\nmysql_variables=\n{\n\thave_ssl=false\n\tdefault_authentication_plugin=\"mysql_native_password\"\n}\n"
    }
  }
}'

# L'opérateur redémarre ProxySQL avec la nouvelle config
# Surveiller en temps réel le démarrage des pods MySQL
kubectl get pods -n devmysql -w

# Vérifier
ROOT_PASS=$(kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data.root}' | base64 -d)

PROXYADMIN_PASS=$(kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data.proxyadmin}' | base64 -d)

kubectl exec pxc-cluster-pxc-db-proxysql-0 -n devmysql -c proxysql -- \
  mysql -uproxyadmin -p"$PROXYADMIN_PASS" -h 127.0.0.1 -P 6032 2>/dev/null \
  -e "SELECT variable_name, variable_value FROM global_variables
      WHERE variable_name IN ('mysql-have_ssl','mysql-default_authentication_plugin');"

mysql-default_authentication_plugin   mysql_native_password
mysql-have_ssl                        false

# Vérifier le statut du cluster MySQL Percona XtraDB
kubectl get pxc -n devmysql
# Vérifier l'état des pods MySQL (PXC + ProxySQL)
kubectl get pods -n devmysql

NAME                 ENDPOINT                               STATUS   PXC   PROXYSQL
pxc-cluster-pxc-db   pxc-cluster-pxc-db-proxysql.devmysql   ready    3/3   3/3

# Tous les users créés par l'opérateur
kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data}' | \
  python3 -c "
import sys, json, base64
data = json.load(sys.stdin)
for k,v in data.items():
    print(f'{k}: {base64.b64decode(v).decode()}')
"

# Récupérer le mot de passe root
ROOT_PASS=$(kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data.root}' | base64 -d)

# Créer le user xsel_admin avec mysql_native_password (compatible phpMyAdmin et apps sans SSL)
kubectl exec pxc-cluster-pxc-db-pxc-0 -n devmysql -c pxc -- \
  mysql -uroot -p"$ROOT_PASS" -e "
    CREATE USER IF NOT EXISTS 'xsel_admin'@'%'
      IDENTIFIED WITH mysql_native_password BY 'XselAdmin2025!';
    GRANT ALL PRIVILEGES ON *.* TO 'xsel_admin'@'%' WITH GRANT OPTION;
    FLUSH PRIVILEGES;
    SELECT user, host, plugin FROM mysql.user WHERE user='xsel_admin';
  "

+------------+------+----------------------+
| user       | host | plugin               |
+------------+------+----------------------+
| xsel_admin | %    | mysql_native_password |
+------------+------+----------------------+

# Récupérer le mot de passe proxyadmin
PROXYADMIN_PASS=$(kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data.proxyadmin}' | base64 -d)

# Vérifier les hostgroups disponibles (10=writer, 11=reader)
kubectl exec pxc-cluster-pxc-db-proxysql-0 -n devmysql -c proxysql -- \
  mysql -uproxyadmin -p"$PROXYADMIN_PASS" -h 127.0.0.1 -P 6032 \
  -e "SELECT hostgroup_id, hostname, port, status FROM mysql_servers;"

# Enregistrer xsel_admin dans ProxySQL sur le hostgroup writer (10)
kubectl exec pxc-cluster-pxc-db-proxysql-0 -n devmysql -c proxysql -- \
  mysql -uproxyadmin -p"$PROXYADMIN_PASS" -h 127.0.0.1 -P 6032 -e "
    INSERT INTO mysql_users (username, password, default_hostgroup, active)
      VALUES ('xsel_admin', 'XselAdmin2025!', 10, 1);
    LOAD MYSQL USERS TO RUNTIME;
    SAVE MYSQL USERS TO DISK;
    SELECT username, active, default_hostgroup FROM mysql_users WHERE username='xsel_admin';
  "

# Tester la connexion via ProxySQL
kubectl exec pxc-cluster-pxc-db-proxysql-0 -n devmysql -c proxysql -- \
  mysql -uxsel_admin -p'XselAdmin2025!' \
  -h 127.0.0.1 -P 3306 \
  -e "SELECT user(), @@hostname, @@version;"

+------------------------------------------------------------------+---------------------------+-----------+
| user()                                                           | @@hostname                | @@version |
+------------------------------------------------------------------+---------------------------+-----------+
| xsel_admin@pxc-cluster-pxc-db-proxysql-0...devmysql.svc...local | pxc-cluster-pxc-db-pxc-1  | 8.4.8-8.1 |
+------------------------------------------------------------------+---------------------------+-----------+

cat > /root/k8s-xsel/phpmyadmin.yaml << 'EOF'
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: phpmyadmin-config
  namespace: devmysql
data:
  config.secret.inc.php: |
    <?php
    $cfg['blowfish_secret'] = 'XSELs3cr3t32CharsL0ngK3y!X2025!!';
  config.user.inc.php: |
    <?php
    $cfg['Servers'][$i]['auth_type'] = 'cookie';
    $cfg['LoginCookieValidity'] = 14400;
    $cfg['DefaultLang'] = 'fr';
  php-session.ini: |
    session.gc_maxlifetime = 14400
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: phpmyadmin
  namespace: devmysql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: phpmyadmin
  template:
    metadata:
      labels:
        app: phpmyadmin
    spec:
      containers:
      - name: phpmyadmin
        image: phpmyadmin:5.2.3
        ports:
        - containerPort: 80
        env:
        - name: PMA_HOST
          value: "pxc-cluster-pxc-db-proxysql.devmysql.svc.cluster.local"
        - name: PMA_PORT
          value: "3306"
        - name: PMA_ABSOLUTE_URI
          value: "https://phpmyadmin.xselcloud.com/"
        - name: UPLOAD_LIMIT
          value: "100M"
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "500m"
        volumeMounts:
        - name: config
          mountPath: /etc/phpmyadmin/config.secret.inc.php
          subPath: config.secret.inc.php
        - name: config
          mountPath: /etc/phpmyadmin/config.user.inc.php
          subPath: config.user.inc.php
        - name: config
          mountPath: /usr/local/etc/php/conf.d/php-session.ini
          subPath: php-session.ini
      volumes:
      - name: config
        configMap:
          name: phpmyadmin-config
---
apiVersion: v1
kind: Service
metadata:
  name: phpmyadmin
  namespace: devmysql
spec:
  selector:
    app: phpmyadmin
  ports:
  - port: 80
    targetPort: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: phpmyadmin-ingress
  namespace: devmysql
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/proxy-body-size: "100m"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "600"
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - phpmyadmin.xselcloud.com
    secretName: phpmyadmin-tls-secret
  rules:
  - host: phpmyadmin.xselcloud.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: phpmyadmin
            port:
              number: 80
EOF

# Déployer phpMyAdmin dans le namespace devmysql
kubectl apply -f /root/k8s-xsel/phpmyadmin.yaml
# Attendre que le déploiement phpMyAdmin soit prêt
kubectl rollout status deployment/phpmyadmin -n devmysql
# Vérifier l'Ingress phpMyAdmin
kubectl get ingress -n devmysql

ROOT_PASS=$(kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data.root}' | base64 -d)

kubectl exec -it \
  $(kubectl get pod -n devmysql -l app=phpmyadmin -o name) \
  -n devmysql -- \
  php -r "
\$c=@mysqli_connect(
  'pxc-cluster-pxc-db-proxysql.devmysql.svc.cluster.local',
  'root','$ROOT_PASS',null,3306
);
echo \$c ? 'CONNEXION OK' : 'ERREUR: '.mysqli_connect_error();
" 2>/dev/null
# Résultat attendu : CONNEXION OK

# Redéfinir ROOT_PASS si nécessaire
ROOT_PASS=$(kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data.root}' | base64 -d)

# Télécharger le script SQL sur master-01
curl -s https://raw.githubusercontent.com/phpmyadmin/phpmyadmin/STABLE/sql/create_tables.sql \
  -o /tmp/create_tables.sql

# Copier dans le pod PXC
kubectl cp /tmp/create_tables.sql \
  devmysql/pxc-cluster-pxc-db-pxc-0:/tmp/create_tables.sql -c pxc

# Créer la base phpmyadmin
kubectl exec pxc-cluster-pxc-db-pxc-0 -n devmysql -c pxc -- \
  bash -c "MYSQL_PWD='$ROOT_PASS' mysql -uroot \
  -e 'CREATE DATABASE IF NOT EXISTS phpmyadmin CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;'" 2>/dev/null

# Importer les tables via redirection stdin
# ⚠️ Ne pas utiliser -e "source ..." : la commande source ne fonctionne pas en mode non-interactif
# ⚠️ Passer le password via MYSQL_PWD pour éviter les problèmes avec les caractères spéciaux
kubectl exec pxc-cluster-pxc-db-pxc-0 -n devmysql -c pxc -- \
  bash -c "MYSQL_PWD='$ROOT_PASS' mysql -uroot phpmyadmin < /tmp/create_tables.sql" 2>/dev/null

# Vérifier — doit afficher 19
kubectl exec pxc-cluster-pxc-db-pxc-0 -n devmysql -c pxc -- \
  bash -c "MYSQL_PWD='$ROOT_PASS' mysql -uroot \
  -e \"SELECT COUNT(*) as tables_pma FROM information_schema.tables
      WHERE table_schema='phpmyadmin';\"" 2>/dev/null

URL      : https://phpmyadmin.xselcloud.com
User     : xsel_admin
Password : XselAdmin2025!

Serveur  : pxc-cluster-pxc-db-proxysql.devmysql.svc.cluster.local:3306
Type     : Percona XtraDB Cluster 8.4.8-8.1
User     : xsel_admin@pxc-cluster-pxc-db-proxysql-2
Version  : phpMyAdmin 5.2.3 ✅
Bases    : information_schema, mysql, performance_schema, phpmyadmin, sys ✅

# Créer le namespace dédié à PostgreSQL
kubectl create namespace devpostgresql

# Créer le fichier de values pour surcharger la request mémoire par défaut (20Mi → 64Mi)
# ⚠️ Même raison que pxc-operator : pg-operator demande 20Mi par défaut,
#    ce qui est rejeté par le LimitRange devpostgresql (min: 20Mi).
cat > /root/k8s-xsel/pg-operator-values.yaml << 'EOF'
resources:
  requests:
    memory: "64Mi"
    cpu: "100m"
  limits:
    memory: "500Mi"
    cpu: "200m"
EOF

# Installer pg-operator avec les values personnalisées
helm install pg-operator percona/pg-operator \
  --namespace devpostgresql \
  --values /root/k8s-xsel/pg-operator-values.yaml

# Vérifier que le pod opérateur démarre correctement
kubectl get pods -n devpostgresql -l app.kubernetes.io/name=pg-operator -w

helm install pg-cluster percona/pg-db \
  --namespace devpostgresql \
  --set instances[0].name=instance1 \
  --set instances[0].replicas=3 \
  --set instances[0].dataVolumeClaimSpec.storageClassName=nfs-storage \
  --set instances[0].dataVolumeClaimSpec.accessModes[0]=ReadWriteOnce \
  --set instances[0].dataVolumeClaimSpec.resources.requests.storage=20Gi

# Vérifier le statut du cluster PostgreSQL Percona
kubectl get pg -n devpostgresql
# Vérifier l'état des pods PostgreSQL (instances + PgBouncer)
kubectl get pods -n devpostgresql

cat > /root/k8s-xsel/pgadmin.yaml << 'EOF'
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pgadmin-pvc
  namespace: devpostgresql
spec:
  accessModes:
  - ReadWriteOnce
  storageClassName: nfs-storage
  resources:
    requests:
      storage: 5Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: pgadmin
  namespace: devpostgresql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: pgadmin
  template:
    metadata:
      labels:
        app: pgadmin
    spec:
      containers:
      - name: pgadmin
        image: dpage/pgadmin4:latest
        env:
        - name: PGADMIN_DEFAULT_EMAIL
          value: "admin@xsel-services.com"
        - name: PGADMIN_DEFAULT_PASSWORD
          value: "XselPgAdmin2025!"
        ports:
        - containerPort: 80
        # ⚠️ pgAdmin 4 est gourmand en mémoire — minimum 512Mi sinon OOMKilled
        resources:
          requests:
            memory: "256Mi"
            cpu: "100m"
          limits:
            memory: "768Mi"
            cpu: "500m"
        volumeMounts:
        - name: pgadmin-data
          mountPath: /var/lib/pgadmin
      volumes:
      - name: pgadmin-data
        persistentVolumeClaim:
          claimName: pgadmin-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: pgadmin
  namespace: devpostgresql
spec:
  selector:
    app: pgadmin
  ports:
  - port: 80
    targetPort: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: pgadmin-ingress
  namespace: devpostgresql
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
    nginx.ingress.kubernetes.io/proxy-body-size: "0"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "600"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "600"
    nginx.ingress.kubernetes.io/proxy-buffer-size: "128k"
    nginx.ingress.kubernetes.io/proxy-buffers-number: "8"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - pgadmin.xselcloud.com
    secretName: pgadmin-tls-secret
  rules:
  - host: pgadmin.xselcloud.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: pgadmin
            port:
              number: 80
EOF

# Déployer pgAdmin 4 dans le namespace devpostgresql
kubectl apply -f /root/k8s-xsel/pgadmin.yaml
# Attendre que le déploiement pgAdmin soit prêt
kubectl rollout status deployment/pgadmin -n devpostgresql
# Vérifier l'Ingress pgAdmin
kubectl get ingress -n devpostgresql

# Voir les secrets disponibles
# Lister les secrets de credentials PostgreSQL créés par l'opérateur
kubectl get secrets -n devpostgresql | grep pguser

# Récupérer tous les credentials
kubectl get secret pg-cluster-pg-db-pguser-pg-cluster-pg-db \
  -n devpostgresql \
  -o jsonpath='{.data}' | \
  python3 -c "
import sys, json, base64
data = json.load(sys.stdin)
for k,v in data.items():
    print(f'{k}: {base64.b64decode(v).decode()}')
"

Host     : pg-cluster-pg-db-pgbouncer.devpostgresql.svc
Port     : 5432
Database : pg-cluster-pg-db
Username : pg-cluster-pg-db
Password : (voir secret pg-cluster-pg-db-pguser-pg-cluster-pg-db)

# Test TCP depuis pgAdmin vers PostgreSQL
kubectl exec -it \
  $(kubectl get pod -n devpostgresql -l app=pgadmin -o name) \
  -n devpostgresql -- \
  python3 -c "
import socket
s = socket.socket()
try:
    s.connect(('pg-cluster-pg-db-pgbouncer.devpostgresql.svc.cluster.local', 5432))
    print('CONNEXION OK port 5432')
except Exception as e:
    print('ERREUR:', e)
s.close()
"
# Résultat attendu : CONNEXION OK port 5432

URL      : https://pgadmin.xselcloud.com
Email    : admin@xsel-services.com
Password : XselPgAdmin2025!

Clic droit sur "Servers" → Register → Server

Onglet Général :
  Nom : XSEL PostgreSQL

Onglet Connexion :
  Nom d'hôte / Adresse  : pg-cluster-pg-db-primary.devpostgresql.svc
  Port                   : 5432
  Base de données        : pg-cluster-pg-db
  Identifiant            : pg-cluster-pg-db
  Mot de passe           : n*_2hI;uALg^m]/+7.+(b/Ua
  Enregistrer le mot de passe : ✅ Activer

Onglet Paramètres → Paramètres de Connexion :
  Mode SSL (sslmode)     : require

STATUS   : ready ✅
POSTGRES : 3/3   ✅
PGBOUNCER: 3/3   ✅

Connexion pgAdmin → PostgreSQL primary : OK ✅
  Serveur  : pg-cluster-pg-db-primary.devpostgresql.svc:5432
  SSL      : require ✅
  Version  : Percona Distribution for PostgreSQL 18.4

helm install pmm percona/pmm \
  --namespace monitoring \
  --set secret.pmm_password=XselPMM2025! \
  --set persistence.storageClassName=nfs-storage \
  --set persistence.dataSize=20Gi \
  --set service.type=ClusterIP

cat > /root/k8s-xsel/pmm-ingress.yaml << 'EOF'
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: pmm-ingress
  namespace: monitoring
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "900"
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - pmm.xselcloud.com
    secretName: pmm-tls-secret
  rules:
  - host: pmm.xselcloud.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: monitoring-service
            port:
              number: 443
EOF

# Créer l'Ingress pour accéder à PMM via NGINX
kubectl apply -f /root/k8s-xsel/pmm-ingress.yaml
# Vérifier que le pod PMM est en Running
kubectl get pods -n monitoring | grep pmm

# Corriger le nom du service et le protocole backend
kubectl patch ingress pmm-ingress -n monitoring --type=json -p='[
  {
    "op": "replace",
    "path": "/spec/rules/0/http/paths/0/backend/service/name",
    "value": "monitoring-service"
  }
]'

kubectl annotate ingress pmm-ingress -n monitoring \
  nginx.ingress.kubernetes.io/backend-protocol=HTTPS \
  --overwrite

ROOT_PASS=$(kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data.root}' | base64 -d)

kubectl exec -it pxc-cluster-pxc-db-pxc-0 -n devmysql -c pxc -- \
  mysql -uroot -p"$ROOT_PASS" 2>/dev/null \
  -e "SHOW STATUS LIKE 'wsrep_cluster_size';
      SHOW STATUS LIKE 'wsrep_local_state_comment';
      SHOW STATUS LIKE 'wsrep_cluster_status';"

wsrep_cluster_size   : 3        ← 3 nodes actifs
wsrep_local_state    : Synced   ← tous synchronisés
wsrep_cluster_status : Primary  ← cluster actif

kubectl get pods -n devpostgresql \
  -l postgres-operator.crunchydata.com/cluster=pg-cluster-pg-db \
  -o custom-columns='NAME:.metadata.name,ROLE:.metadata.labels.postgres-operator\.crunchydata\.com/role'

NAME                               ROLE
pg-cluster-pg-db-instance1-r58g-0  primary  ← écritures + lectures
pg-cluster-pg-db-instance1-tk8f-0  replica  ← lectures seulement
pg-cluster-pg-db-instance1-z7dr-0  replica  ← lectures seulement
pg-cluster-pg-db-pgbouncer-xxx      pgbouncer (x3)

echo "=== MySQL ===" && kubectl get pxc -n devmysql
echo "=== Pods MySQL ===" && kubectl get pods -n devmysql
echo "=== PostgreSQL ===" && kubectl get pg -n devpostgresql
echo "=== Pods PostgreSQL ===" && kubectl get pods -n devpostgresql
echo "=== phpMyAdmin ===" && kubectl get ingress -n devmysql
echo "=== pgAdmin ===" && kubectl get ingress -n devpostgresql
echo "=== PMM ===" && kubectl get pods -n monitoring | grep pmm

=== MySQL ===
NAME                 ENDPOINT                               STATUS   PXC   PROXYSQL
pxc-cluster-pxc-db   pxc-cluster-pxc-db-proxysql.devmysql   ready    3     3       ✅

=== Pods MySQL ===
phpmyadmin              1/1 Running ✅
pxc-cluster-pxc-db-proxysql-0/1/2   3/3 Running ✅
pxc-cluster-pxc-db-pxc-0/1/2        3/3 Running ✅
pxc-operator            1/1 Running ✅

=== PostgreSQL ===
NAME               STATUS   POSTGRES   PGBOUNCER
pg-cluster-pg-db   ready    3          3         ✅

=== Pods PostgreSQL ===
instance1-r58g-0 / tk8f-0 / z7dr-0   4/4 Running ✅
pgbouncer (x3)                        2/2 Running ✅
pgadmin                               1/1 Running ✅

=== phpMyAdmin ===
phpmyadmin-ingress   nginx   phpmyadmin.xselcloud.com   80, 443 ✅

=== pgAdmin ===
pgadmin-ingress   nginx   pgadmin.xselcloud.com   80, 443 ✅

=== PMM ===
pmm-0   1/1 Running ✅

Serveur Plesk
    │
    ▼
HAProxy (95.111.238.94)
    ├── :3306  →  devnode-01/02:30307  →  ProxySQL  →  PXC MySQL
    └── :5432  →  devnode-01/02:30432  →  PGBouncer →  PostgreSQL

kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data}' | \
  python3 -c "
import sys, json, base64
data = json.load(sys.stdin)
for k,v in data.items():
    print(f'{k}: {base64.b64decode(v).decode()}')
"

kubectl get secret pg-cluster-pg-db-pguser-pg-cluster-pg-db \
  -n devpostgresql \
  -o jsonpath='{.data}' | \
  python3 -c "
import sys, json, base64
data = json.load(sys.stdin)
for k,v in data.items():
    print(f'{k}: {base64.b64decode(v).decode()}')
"

kubectl patch svc pxc-cluster-pxc-db-proxysql -n devmysql \
  --type='json' -p='[
    {"op":"replace","path":"/spec/type","value":"NodePort"},
    {"op":"add","path":"/spec/ports/0/nodePort","value":30307}
  ]'

cat << 'EOFYAML' | kubectl apply -f -
apiVersion: v1
kind: Service
metadata:
  name: pg-pgbouncer-nodeport
  namespace: devpostgresql
spec:
  type: NodePort
  selector:
    postgres-operator.crunchydata.com/role: pgbouncer
  ports:
  - port: 5432
    targetPort: 5432
    nodePort: 30432
    protocol: TCP
EOFYAML

# Vérifier que le service NodePort PostgreSQL pointe vers les bons pods
kubectl get endpoints pg-pgbouncer-nodeport -n devpostgresql
# Attendu : 3 endpoints (172.16.11.x:5432, 172.16.12.x:5432, 172.16.12.x:5432)

# Tester la connectivité TCP vers le NodePort PGBouncer
nc -zv 192.168.1.1 30432
# Attendu : Connected

kubectl get svc pg-pgbouncer-nodeport -n devpostgresql -o yaml \
  > /root/k8s-xsel/pg-pgbouncer-nodeport.yaml

# Copier la config depuis le container
# Extraire la configuration HAProxy actuelle depuis le conteneur
docker cp xsel-haproxy-lb:/usr/local/etc/haproxy/haproxy.cfg /tmp/haproxy.cfg

# Ajouter les blocs MySQL et PostgreSQL
cat >> /tmp/haproxy.cfg << 'EOFCFG'

# ========================================
# MYSQL - Percona XtraDB via ProxySQL
# ========================================
frontend mysql_frontend
    bind *:3306
    mode tcp
    option tcplog
    default_backend mysql_backend

backend mysql_backend
    mode tcp
    balance roundrobin
    option tcp-check
    server devnode-01 192.168.1.1:30307 check inter 5s fall 3 rise 2
    server devnode-02 192.168.1.2:30307 check inter 5s fall 3 rise 2
    server devnode-03 192.168.1.3:30307 check inter 5s fall 3 rise 2

# ========================================
# POSTGRESQL - PGBouncer
# ========================================
frontend postgres_frontend
    bind *:5432
    mode tcp
    option tcplog
    default_backend postgres_backend

backend postgres_backend
    mode tcp
    balance roundrobin
    option tcp-check
    server devnode-01 192.168.1.1:30432 check inter 5s fall 3 rise 2
    server devnode-02 192.168.1.2:30432 check inter 5s fall 3 rise 2
    server devnode-03 192.168.1.3:30432 check inter 5s fall 3 rise 2
EOFCFG

# Valider la config
# Remettre la configuration modifiée dans le conteneur
docker cp /tmp/haproxy.cfg xsel-haproxy-lb:/usr/local/etc/haproxy/haproxy.cfg
# Valider la nouvelle configuration avant rechargement
docker exec xsel-haproxy-lb haproxy -f /usr/local/etc/haproxy/haproxy.cfg -c
# Attendu : Configuration file is valid

# Recharger HAProxy
# Redémarrer HAProxy pour appliquer la nouvelle configuration
docker restart xsel-haproxy-lb

ROOT_PASS=$(kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data.root}' | base64 -d)

PROXYADMIN_PASS=$(kubectl get secret pxc-cluster-pxc-db-secrets \
  -n devmysql -o jsonpath='{.data.proxyadmin}' | base64 -d)

# 1. Créer le user xsel_admin dans PXC
kubectl exec -it pxc-cluster-pxc-db-pxc-0 -n devmysql -c pxc -- \
  mysql -uroot -p"$ROOT_PASS" -e "
    CREATE USER IF NOT EXISTS 'xsel_admin'@'%' IDENTIFIED WITH mysql_native_password BY 'XselAdmin2025!';
    GRANT ALL PRIVILEGES ON *.* TO 'xsel_admin'@'%' WITH GRANT OPTION;
    FLUSH PRIVILEGES;
  "

# 2. Ajouter xsel_admin dans ProxySQL
kubectl exec -it pxc-cluster-pxc-db-proxysql-0 -n devmysql -c proxysql -- \
  mysql -uproxyadmin -p"$PROXYADMIN_PASS" -h 127.0.0.1 -P 6032 -e "
    INSERT INTO mysql_users(username, password, active, default_hostgroup)
    VALUES ('xsel_admin', 'XselAdmin2025!', 1, 11);
    LOAD MYSQL USERS TO RUNTIME;
    SAVE MYSQL USERS TO DISK;
  "