#!/bin/bash
# Partie 1 - Pré-requis et installation des composants Kubernetes
# À exécuter sur TOUS les nœuds (master + workers)
# Compatible CentOS Stream 10

set -e

# --- Détermination du rôle du nœud ---
NODE_ROLE=""

usage() {
    echo "Usage: $0 [--role master|worker] | [master|worker]"
    echo "  --role master|worker  : forcer le rôle explicitement"
    echo "  master|worker         : argument positionnel (compatibilité)"
    echo "  (aucun argument)      : autodetect via hostname (*master*, *control* → master)"
    exit 1
}

while [[ $# -gt 0 ]]; do
    case "$1" in
        --role)
            shift
            case "$1" in
                master|worker) NODE_ROLE="$1" ;;
                *) echo "Erreur: --role attend 'master' ou 'worker', reçu '$1'"; usage ;;
            esac
            shift
            ;;
        master|worker)
            NODE_ROLE="$1"
            shift
            ;;
        -h|--help) usage ;;
        *) echo "Argument inconnu: $1"; usage ;;
    esac
done

if [[ -z "$NODE_ROLE" ]]; then
    if [[ "$(hostname)" == *"master"* ]] || [[ "$(hostname)" == *"control"* ]]; then
        NODE_ROLE="master"
        echo "Autodetect: rôle 'master' détecté via hostname ($(hostname))"
    else
        NODE_ROLE="worker"
        echo "Autodetect: rôle 'worker' (hostname: $(hostname))"
    fi
else
    echo "Rôle: '$NODE_ROLE' (explicite)"
fi

echo "=== Installation des pré-requis Kubernetes sur CentOS 10 [rôle: $NODE_ROLE] ==="

# Désactiver le swap (requis par Kubernetes)
echo "Désactivation du swap..."
sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

# Installer container-selinux AVANT containerd pour que les labels SELinux soient corrects
# POURQUOI: container-selinux fournit la policy qui confine chaque container dans le label
#           container_t — un container compromis ne peut pas lire /etc/passwd ni écrire
#           dans les répertoires système de l'hôte, même en root dans le container.
echo "Installation de container-selinux..."
sudo dnf install -y container-selinux

# Maintenir SELinux en mode enforcing
# POURQUOI: Le mode permissive ne fait que logger les violations sans les bloquer —
#           c'est une fausse sécurité. En enforcing + container-selinux, les appels
#           système non autorisés depuis les containers sont bloqués au niveau kernel.
echo "Vérification SELinux en mode enforcing..."
sudo setenforce 1 || true
SELINUX_CURRENT=$(getenforce 2>/dev/null || echo "Unknown")
if [[ "$SELINUX_CURRENT" != "Enforcing" ]]; then
    echo "ATTENTION: SELinux n'est pas en mode Enforcing (actuel: $SELINUX_CURRENT)"
    echo "Vérifier /etc/selinux/config — SELINUX doit être 'enforcing'"
fi

# Charger les modules kernel nécessaires
# overlay, br_netfilter : requis par containerd et le CNI
# ip_vs, ip_vs_rr/rr/wrr/sh : requis par Cilium en mode kube-proxy replacement (IPVS)
# nf_conntrack : suivi des connexions réseau (requis par iptables/eBPF)
echo "Configuration des modules kernel..."
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
ip_vs
ip_vs_rr
ip_vs_wrr
ip_vs_sh
nf_conntrack
EOF

sudo modprobe overlay
sudo modprobe br_netfilter
sudo modprobe ip_vs
sudo modprobe ip_vs_rr
sudo modprobe ip_vs_wrr
sudo modprobe ip_vs_sh
sudo modprobe nf_conntrack 2>/dev/null || sudo modprobe nf_conntrack_ipv4 2>/dev/null || true

# Configuration sysctl
# bridge-nf-call-iptables/ip6tables : trafic bridgé traité par iptables (requis CNI)
# ip_forward : routage IP entre interfaces (requis pod-to-pod)
# rp_filter=0 : Cilium eBPF requiert que le reverse path filtering soit désactivé
# inotify params : requis par Cilium pour surveiller les changements de configuration
echo "Configuration sysctl..."
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
net.ipv4.conf.all.rp_filter         = 0
fs.inotify.max_user_watches         = 524288
fs.inotify.max_user_instances       = 512
EOF

sudo sysctl --system

# Configurer firewalld avec les règles Kubernetes
# POURQUOI: Désactiver firewalld entièrement supprime toute isolation réseau au niveau hôte.
#           Si un pod bypass le CNI (via un exploit), firewalld local est la dernière barrière.
#           Defense in depth : security group cloud + firewalld hôte + NetworkPolicy CNI.
echo "Configuration de firewalld avec les règles Kubernetes..."
sudo systemctl enable firewalld
sudo systemctl start firewalld

if [[ "$NODE_ROLE" == "master" ]]; then
    echo "  Règles control plane..."
    sudo firewall-cmd --permanent --add-port=6443/tcp        # API server
    sudo firewall-cmd --permanent --add-port=2379-2380/tcp   # etcd client + peer
    sudo firewall-cmd --permanent --add-port=10257/tcp       # kube-controller-manager
    sudo firewall-cmd --permanent --add-port=10259/tcp       # kube-scheduler
fi

echo "  Règles communes (kubelet + réseau)..."
sudo firewall-cmd --permanent --add-port=10250/tcp           # kubelet API
sudo firewall-cmd --permanent --add-port=30000-32767/tcp     # NodePort services
sudo firewall-cmd --permanent --add-port=53/tcp              # DNS (CoreDNS)
sudo firewall-cmd --permanent --add-port=53/udp              # DNS (CoreDNS)

echo "  Règles Cilium..."
sudo firewall-cmd --permanent --add-port=4240/tcp            # Cilium health checks
sudo firewall-cmd --permanent --add-port=4244/tcp            # Hubble server
sudo firewall-cmd --permanent --add-port=4245/tcp            # Hubble relay
sudo firewall-cmd --permanent --add-port=51871/udp           # WireGuard (chiffrement inter-nœuds)
sudo firewall-cmd --permanent --add-port=8472/udp            # VXLAN (fallback)

sudo firewall-cmd --permanent --add-masquerade
sudo firewall-cmd --reload
echo "  ✓ firewalld configuré"

# Installation de containerd depuis le repo Docker
echo "Ajout du repo Docker pour containerd..."
sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

echo "Installation de containerd..."
sudo dnf install -y containerd.io

sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml > /dev/null

# Activer systemd cgroup driver (OBLIGATOIRE pour kubeadm)
echo "Activation du driver cgroup systemd pour containerd..."
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml

sudo systemctl restart containerd
sudo systemctl enable containerd

# Installation des paquets Kubernetes
echo "Configuration du repo Kubernetes..."
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.34/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.34/rpm/repodata/repomd.xml.key
exclude=kubelet kubeadm kubectl cri-tools kubernetes-cni
EOF

if [[ "$NODE_ROLE" == "master" ]]; then
    echo "Installation de kubeadm, kubelet, kubectl (control plane)..."
    sudo dnf install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
else
    echo "Installation de kubeadm, kubelet (worker)..."
    sudo dnf install -y kubelet kubeadm --disableexcludes=kubernetes
fi

echo "Verrouillage des versions..."
sudo dnf install -y 'dnf-command(versionlock)' 2>/dev/null || true
if [[ "$NODE_ROLE" == "master" ]]; then
    sudo dnf versionlock add kubelet kubeadm kubectl 2>/dev/null || echo "Note: versionlock non disponible"
else
    sudo dnf versionlock add kubelet kubeadm 2>/dev/null || echo "Note: versionlock non disponible"
fi

# Installer Helm sur le master (requis pour Cilium, KubeArmor, Kyverno)
if [[ "$NODE_ROLE" == "master" ]]; then
    if ! command -v helm &>/dev/null; then
        echo "Installation de Helm..."
        HELM_VERSION="v3.17.3"
        curl -L "https://get.helm.sh/helm-${HELM_VERSION}-linux-amd64.tar.gz" -o /tmp/helm.tar.gz
        tar -xzf /tmp/helm.tar.gz -C /tmp
        sudo mv /tmp/linux-amd64/helm /usr/local/bin/helm
        rm -rf /tmp/linux-amd64 /tmp/helm.tar.gz
        echo "  ✓ Helm ${HELM_VERSION} installé"
    else
        echo "  ✓ Helm déjà installé: $(helm version --short)"
    fi
fi

sudo systemctl enable kubelet

echo ""
echo "=== Vérifications ==="
echo "Swap désactivé:      $(free -h | grep Swap | awk '{print $2}') (doit être 0)"
SELINUX_STATUS=$(getenforce 2>/dev/null || echo "Unknown")
if [[ "$SELINUX_STATUS" == "Enforcing" ]]; then
    echo "SELinux:             $SELINUX_STATUS ✓"
else
    echo "SELinux:             $SELINUX_STATUS ⚠ ATTENTION: doit être Enforcing"
fi
echo "Modules kernel:      $(lsmod | grep -E 'overlay|br_netfilter|ip_vs|nf_conntrack' | wc -l)/7 chargés"
echo "firewalld:           $(systemctl is-active firewalld)"
echo "containerd:          $(systemctl is-active containerd)"
echo "SystemdCgroup:       $(grep 'SystemdCgroup = true' /etc/containerd/config.toml > /dev/null && echo 'activé ✓' || echo 'ATTENTION: non activé!')"
echo ""
echo "✓ Pré-requis installés avec succès!"
echo "Version kubeadm: $(kubeadm version -o short)"
echo "Version kubelet: $(kubelet --version)"
if command -v kubectl &>/dev/null; then
    echo "Version kubectl: $(kubectl version --client -o yaml | grep gitVersion)"
fi
if command -v helm &>/dev/null; then
    echo "Version helm:    $(helm version --short)"
fi