argocd/scripts/init-pki.sh

#!/bin/bash

# Script d'initialisation de la PKI interne
# Ce script vérifie et crée le certificat CA root si nécessaire
# Usage: ./init-pki.sh [--context CLUSTER_CONTEXT]

set -e

CONTEXT="${KUBECTL_CONTEXT:-cluster-ops}"
NAMESPACE="certificates-ops"
CERT_NAME="ca-root-certificate"
SECRET_NAME="ca-root-secret"
ISSUER_NAME="ca-root-issuer"

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --context)
            CONTEXT="$2"
            shift 2
            ;;
        *)
            echo "Usage: $0 [--context CLUSTER_CONTEXT]"
            echo "  --context: Contexte kubectl (défaut: cluster-ops)"
            exit 1
            ;;
    esac
done

echo "=== Initialisation de la PKI interne ==="
echo "Cluster: $CONTEXT"
echo "Namespace: $NAMESPACE"
echo ""

# Vérifier que kubectl est disponible
if ! command -v kubectl &> /dev/null; then
    echo "❌ kubectl n'est pas installé"
    exit 1
fi

# Vérifier l'accès au cluster
if ! kubectl --context="$CONTEXT" cluster-info &> /dev/null; then
    echo "❌ Impossible d'accéder au cluster $CONTEXT"
    exit 1
fi

# Vérifier que cert-manager est installé
if ! kubectl --context="$CONTEXT" get crd certificates.cert-manager.io &> /dev/null; then
    echo "❌ cert-manager n'est pas installé sur le cluster $CONTEXT"
    exit 1
fi

# Vérifier que le namespace existe
if ! kubectl --context="$CONTEXT" get namespace "$NAMESPACE" &> /dev/null; then
    echo "📦 Création du namespace $NAMESPACE..."
    kubectl --context="$CONTEXT" create namespace "$NAMESPACE"
fi

# Vérifier que le ClusterIssuer ca-root-issuer existe
if ! kubectl --context="$CONTEXT" get clusterissuer "$ISSUER_NAME" &> /dev/null; then
    echo "❌ Le ClusterIssuer $ISSUER_NAME n'existe pas"
    echo "   Assurez-vous qu'il est déployé via ArgoCD"
    exit 1
fi

# Vérifier si le secret existe déjà
if kubectl --context="$CONTEXT" get secret "$SECRET_NAME" -n "$NAMESPACE" &> /dev/null; then
    echo "✅ Le secret $SECRET_NAME existe déjà"
    echo "   La PKI est déjà initialisée"
    
    # Vérifier l'état du certificat
    if kubectl --context="$CONTEXT" get certificate "$CERT_NAME" -n "$NAMESPACE" &> /dev/null; then
        CERT_STATUS=$(kubectl --context="$CONTEXT" get certificate "$CERT_NAME" -n "$NAMESPACE" \
            -o jsonpath='{.status.conditions[?(@.type=="Ready")].status}' 2>/dev/null || echo "Unknown")
        
        if [ "$CERT_STATUS" == "True" ]; then
            echo "✅ Le certificat CA root est prêt"
            echo ""
            echo "📋 Informations du certificat:"
            kubectl --context="$CONTEXT" get certificate "$CERT_NAME" -n "$NAMESPACE" -o wide
            echo ""
            echo "✅ La PKI est opérationnelle"
            exit 0
        else
            echo "⚠️  Le certificat existe mais n'est pas encore prêt (status: $CERT_STATUS)"
            echo "   Attente de la génération..."
        fi
    else
        echo "⚠️  Le secret existe mais le Certificate n'existe pas"
        echo "   Cela peut indiquer un problème de configuration"
    fi
else
    echo "📋 Le secret $SECRET_NAME n'existe pas encore"
    echo "   Vérification du Certificate..."
fi

# Vérifier si le Certificate existe
if ! kubectl --context="$CONTEXT" get certificate "$CERT_NAME" -n "$NAMESPACE" &> /dev/null; then
    echo "❌ Le Certificate $CERT_NAME n'existe pas dans le namespace $NAMESPACE"
    echo "   Assurez-vous qu'il est déployé via ArgoCD"
    echo ""
    echo "   Le Certificate doit être créé dans:"
    echo "   helm/certificates/ops/templates/certificate-ca-root.yaml"
    exit 1
fi

# Attendre que le certificat soit généré
echo "⏳ Attente de la génération du certificat CA root..."
echo "   (Cela peut prendre quelques secondes)"

MAX_WAIT=120  # 2 minutes
ELAPSED=0
INTERVAL=5

while [ $ELAPSED -lt $MAX_WAIT ]; do
    if kubectl --context="$CONTEXT" get secret "$SECRET_NAME" -n "$NAMESPACE" &> /dev/null; then
        CERT_STATUS=$(kubectl --context="$CONTEXT" get certificate "$CERT_NAME" -n "$NAMESPACE" \
            -o jsonpath='{.status.conditions[?(@.type=="Ready")].status}' 2>/dev/null || echo "False")
        
        if [ "$CERT_STATUS" == "True" ]; then
            echo ""
            echo "✅ Certificat CA root généré avec succès !"
            break
        fi
    fi
    
    echo -n "."
    sleep $INTERVAL
    ELAPSED=$((ELAPSED + INTERVAL))
done

echo ""

# Vérifier le résultat final
if ! kubectl --context="$CONTEXT" get secret "$SECRET_NAME" -n "$NAMESPACE" &> /dev/null; then
    echo ""
    echo "❌ Le secret n'a pas été généré après $MAX_WAIT secondes"
    echo ""
    echo "🔍 Diagnostic:"
    echo ""
    echo "1. Vérifier le Certificate:"
    kubectl --context="$CONTEXT" get certificate "$CERT_NAME" -n "$NAMESPACE" -o yaml
    echo ""
    echo "2. Vérifier les événements:"
    kubectl --context="$CONTEXT" get events -n "$NAMESPACE" --sort-by='.lastTimestamp' | tail -10
    echo ""
    echo "3. Vérifier les logs de cert-manager:"
    echo "   kubectl --context=$CONTEXT logs -n cert-manager-ops -l app.kubernetes.io/name=cert-manager --tail=50"
    exit 1
fi

# Vérifier que le ClusterIssuer ca-issuer fonctionne maintenant
echo "🔍 Vérification du ClusterIssuer ca-issuer..."
sleep 2

if kubectl --context="$CONTEXT" get clusterissuer ca-issuer &> /dev/null; then
    ISSUER_STATUS=$(kubectl --context="$CONTEXT" get clusterissuer ca-issuer \
        -o jsonpath='{.status.conditions[?(@.type=="Ready")].status}' 2>/dev/null || echo "False")
    
    if [ "$ISSUER_STATUS" == "True" ]; then
        echo "✅ Le ClusterIssuer ca-issuer est prêt"
    else
        echo "⚠️  Le ClusterIssuer ca-issuer n'est pas encore prêt (status: $ISSUER_STATUS)"
        echo "   Il devrait se mettre à jour automatiquement"
    fi
fi

echo ""
echo "=== Résumé ==="
echo "✅ Certificat CA root: $(kubectl --context="$CONTEXT" get certificate "$CERT_NAME" -n "$NAMESPACE" -o jsonpath='{.status.conditions[?(@.type=="Ready")].status}' 2>/dev/null || echo "Unknown")"
echo "✅ Secret CA root: $(kubectl --context="$CONTEXT" get secret "$SECRET_NAME" -n "$NAMESPACE" &> /dev/null && echo "Existe" || echo "Manquant")"
echo ""
echo "📋 Prochaines étapes:"
echo "1. Extraire le certificat CA root:"
echo "   ./scripts/extract-ca-root-cert.sh --context=$CONTEXT"
echo ""
echo "2. Distribuer le certificat aux clients (voir docs/PKI-INTERNE.md)"
echo ""
echo "3. Créer des certificats pour vos applications internes en utilisant 'ca-issuer'"
echo ""
echo "🎉 Initialisation terminée !"