update sync tls

This commit is contained in:
2026-01-22 02:34:41 +01:00
parent 50b7092809
commit 2e0b425939
3 changed files with 446 additions and 1 deletions

View File

@@ -0,0 +1,268 @@
# Guide de Vérification - TLS Sync Wildcard
Ce guide vous explique comment vérifier que le CronJob de synchronisation des certificats wildcard fonctionne correctement.
## 1. Vérifier que le CronJob est déployé
```bash
# Vérifier que le CronJob existe
kubectl get cronjob -n certificates-ops tls-sync-wildcard --context=cluster-ops
# Voir les détails du CronJob
kubectl describe cronjob -n certificates-ops tls-sync-wildcard --context=cluster-ops
# Vérifier le schedule configuré
kubectl get cronjob -n certificates-ops tls-sync-wildcard --context=cluster-ops -o jsonpath='{.spec.schedule}' && echo
```
**Résultat attendu** : Le CronJob doit être présent avec un schedule (par exemple `0 * * * *` pour toutes les heures).
## 2. Vérifier que les Jobs sont créés
```bash
# Lister tous les Jobs créés par le CronJob
kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops
# Voir les Jobs récents (dernières 24h)
kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --sort-by=.metadata.creationTimestamp | tail -5
# Vérifier le statut du dernier Job
kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops -o wide | head -2
```
**Résultat attendu** : Vous devriez voir des Jobs avec le statut `Complete` ou `Running`.
## 3. Voir les logs des Jobs
```bash
# Voir les logs du dernier Job
kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=100
# Voir les logs d'un Job spécifique
JOB_NAME=$(kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --sort-by=.metadata.creationTimestamp -o jsonpath='{.items[-1].metadata.name}')
kubectl logs -n certificates-ops job/$JOB_NAME --context=cluster-ops
# Suivre les logs en temps réel (si un Job est en cours)
kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops -f
```
**Résultat attendu** : Les logs doivent montrer :
- `=== Synchronisation automatique des secrets TLS ===`
- `📋 Traitement du certificat: wildcard-dev-tls`
- `🌐 Certificat wildcard détecté`
- `✅ Synchronisé avec succès dans <namespace>`
## 4. Vérifier que les secrets sont synchronisés
### Dans le cluster DEV
```bash
# Vérifier que le secret existe dans headlamp-dev
kubectl get secret wildcard-dev-tls -n headlamp-dev --context=cluster-dev
# Vérifier que le secret existe dans homarr-dev
kubectl get secret wildcard-dev-tls -n homarr-dev --context=cluster-dev
# Vérifier que le secret existe dans longhorn-dev
kubectl get secret wildcard-dev-tls -n longhorn-dev --context=cluster-dev
# Vérifier les détails d'un secret (date de création, taille, etc.)
kubectl describe secret wildcard-dev-tls -n headlamp-dev --context=cluster-dev
```
**Résultat attendu** : Les secrets doivent exister dans tous les namespaces configurés.
### Comparer les secrets entre namespaces
```bash
# Comparer les certificats (doivent être identiques)
kubectl get secret wildcard-dev-tls -n certificates-ops --context=cluster-ops -o jsonpath='{.data.tls\.crt}' | base64 -d | openssl x509 -noout -subject -dates
kubectl get secret wildcard-dev-tls -n headlamp-dev --context=cluster-dev -o jsonpath='{.data.tls\.crt}' | base64 -d | openssl x509 -noout -subject -dates
```
**Résultat attendu** : Les certificats doivent être identiques (même sujet, mêmes dates).
## 5. Déclencher manuellement une synchronisation
```bash
# Créer un Job manuel à partir du CronJob
kubectl create job --from=cronjob/tls-sync-wildcard tls-sync-wildcard-manual-$(date +%s) -n certificates-ops --context=cluster-ops
# Attendre quelques secondes puis voir les logs
sleep 5
kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=50
```
**Résultat attendu** : Un nouveau Job est créé et exécuté immédiatement.
## 6. Vérifier les permissions RBAC
```bash
# Vérifier que le ServiceAccount existe
kubectl get serviceaccount tls-sync-wildcard -n certificates-ops --context=cluster-ops
# Vérifier que le ClusterRole existe
kubectl get clusterrole tls-sync-wildcard --context=cluster-ops
# Vérifier que le ClusterRoleBinding existe
kubectl get clusterrolebinding tls-sync-wildcard --context=cluster-ops
# Tester les permissions du ServiceAccount
kubectl auth can-i get secrets --namespace=certificates-ops --as=system:serviceaccount:certificates-ops:tls-sync-wildcard --context=cluster-ops
kubectl auth can-i create secrets --namespace=headlamp-dev --as=system:serviceaccount:certificates-ops:tls-sync-wildcard --context=cluster-dev
```
**Résultat attendu** : Toutes les commandes doivent retourner `yes`.
## 7. Vérifier le ConfigMap avec le script
```bash
# Vérifier que le ConfigMap existe
kubectl get configmap tls-sync-wildcard-script -n certificates-ops --context=cluster-ops
# Voir le contenu du script (premières lignes)
kubectl get configmap tls-sync-wildcard-script -n certificates-ops --context=cluster-ops -o jsonpath='{.data.sync-all-certificates\.sh}' | head -20
```
**Résultat attendu** : Le ConfigMap doit exister et contenir le script.
## 8. Vérifier le Secret kubeconfig
```bash
# Vérifier que le Secret existe
kubectl get secret tls-sync-kubeconfig -n certificates-ops --context=cluster-ops
# Vérifier que le fichier config est présent
kubectl get secret tls-sync-kubeconfig -n certificates-ops --context=cluster-ops -o jsonpath='{.data.config}' | base64 -d | head -5
```
**Résultat attendu** : Le Secret doit exister et contenir un fichier `config` valide.
## 9. Script de vérification complète
Créez un script pour vérifier tout d'un coup :
```bash
#!/bin/bash
# Script de vérification complète du TLS Sync
echo "=== Vérification du TLS Sync Wildcard ==="
echo ""
echo "1. CronJob..."
kubectl get cronjob -n certificates-ops tls-sync-wildcard --context=cluster-ops 2>/dev/null && echo "✅ CronJob existe" || echo "❌ CronJob manquant"
echo ""
echo "2. Derniers Jobs..."
kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --sort-by=.metadata.creationTimestamp | tail -3
echo ""
echo "3. Secrets dans cluster-dev..."
for ns in headlamp-dev homarr-dev longhorn-dev; do
if kubectl get secret wildcard-dev-tls -n "$ns" --context=cluster-dev &>/dev/null; then
echo "✅ $ns: secret présent"
else
echo "❌ $ns: secret manquant"
fi
done
echo ""
echo "4. Logs du dernier Job..."
kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=20 2>/dev/null | tail -5
echo ""
echo "=== Vérification terminée ==="
```
## 10. Dépannage des problèmes courants
### Le CronJob ne crée pas de Jobs
```bash
# Vérifier les événements
kubectl get events -n certificates-ops --context=cluster-ops --sort-by='.lastTimestamp' | grep tls-sync-wildcard | tail -10
# Vérifier le schedule
kubectl get cronjob -n certificates-ops tls-sync-wildcard --context=cluster-ops -o yaml | grep -A 2 schedule
```
### Les Jobs échouent
```bash
# Voir les détails du Job en échec
kubectl describe job -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops | tail -30
# Voir les logs d'erreur
kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=100 | grep -i error
```
### Les secrets ne sont pas synchronisés
```bash
# Vérifier que le certificat source existe
kubectl get certificate wildcard-dev-tls -n certificates-ops --context=cluster-ops
# Vérifier que le secret source existe
kubectl get secret wildcard-dev-tls -n certificates-ops --context=cluster-ops
# Vérifier les logs pour voir pourquoi la synchronisation a échoué
kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=200 | grep -A 10 "wildcard-dev-tls"
```
### Erreur "context not found"
```bash
# Vérifier que le Secret kubeconfig contient tous les contextes
kubectl get secret tls-sync-kubeconfig -n certificates-ops --context=cluster-ops -o jsonpath='{.data.config}' | base64 -d | grep -E "contexts:|name:"
# Tester l'accès aux clusters depuis un pod de test
kubectl run -it --rm test-kubeconfig --image=bitnami/kubectl:1.31 --restart=Never \
-n certificates-ops \
--context=cluster-ops \
--overrides='
{
"spec": {
"containers": [{
"name": "test-kubeconfig",
"image": "bitnami/kubectl:1.31",
"volumeMounts": [{
"name": "kubeconfig",
"mountPath": "/root/.kube",
"readOnly": true
}]
}],
"volumes": [{
"name": "kubeconfig",
"secret": {
"secretName": "tls-sync-kubeconfig"
}
}]
}
}' \
-- kubectl config get-contexts
```
## 11. Monitoring continu
Pour surveiller en continu :
```bash
# Watch les Jobs
watch -n 5 'kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops'
# Watch les secrets dans un namespace
watch -n 10 'kubectl get secret wildcard-dev-tls -n headlamp-dev --context=cluster-dev'
```
## Résumé des commandes essentielles
```bash
# Vérification rapide (tout en une fois)
kubectl get cronjob,jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops && \
kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=30 && \
echo "--- Secrets dans cluster-dev ---" && \
kubectl get secret wildcard-dev-tls -n headlamp-dev --context=cluster-dev && \
kubectl get secret wildcard-dev-tls -n homarr-dev --context=cluster-dev && \
kubectl get secret wildcard-dev-tls -n longhorn-dev --context=cluster-dev
```

View File

@@ -1,7 +1,7 @@
# Configuration pour le CronJob de synchronisation des secrets TLS wildcard # Configuration pour le CronJob de synchronisation des secrets TLS wildcard
tlsSync: tlsSync:
# Schedule Cron pour la synchronisation (toutes les heures par défaut) # Schedule Cron pour la synchronisation (toutes les heures par défaut)
schedule: "0 * * * *" # Toutes les heures schedule: "*/5 * * * *" # Toutes les 5 minutes
# Cluster source (où les certificats sont générés) # Cluster source (où les certificats sont générés)
sourceCluster: "cluster-ops" sourceCluster: "cluster-ops"

177
scripts/verify-tls-sync.sh Normal file
View File

@@ -0,0 +1,177 @@
#!/bin/bash
# Script de vérification rapide du TLS Sync Wildcard
# Usage: ./verify-tls-sync.sh [--context cluster-ops]
set -e
CONTEXT="${1:-cluster-ops}"
NAMESPACE="certificates-ops"
echo "=== Vérification du TLS Sync Wildcard ==="
echo "Contexte: $CONTEXT"
echo "Namespace: $NAMESPACE"
echo ""
# Couleurs pour l'affichage
GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color
# Fonction pour afficher un résultat
check_result() {
if [ $? -eq 0 ]; then
echo -e "${GREEN}$1${NC}"
else
echo -e "${RED}$1${NC}"
fi
}
# 1. Vérifier le CronJob
echo "1. Vérification du CronJob..."
if kubectl get cronjob -n "$NAMESPACE" tls-sync-wildcard --context="$CONTEXT" &>/dev/null; then
echo -e "${GREEN}✅ CronJob existe${NC}"
SCHEDULE=$(kubectl get cronjob -n "$NAMESPACE" tls-sync-wildcard --context="$CONTEXT" -o jsonpath='{.spec.schedule}' 2>/dev/null)
echo " Schedule: $SCHEDULE"
else
echo -e "${RED}❌ CronJob manquant${NC}"
exit 1
fi
echo ""
# 2. Vérifier les Jobs
echo "2. Vérification des Jobs..."
JOBS=$(kubectl get jobs -n "$NAMESPACE" -l app=tls-sync-wildcard --context="$CONTEXT" --no-headers 2>/dev/null | wc -l)
if [ "$JOBS" -gt 0 ]; then
echo -e "${GREEN}$JOBS Job(s) trouvé(s)${NC}"
echo ""
echo " Derniers Jobs:"
kubectl get jobs -n "$NAMESPACE" -l app=tls-sync-wildcard --context="$CONTEXT" --sort-by=.metadata.creationTimestamp -o custom-columns=NAME:.metadata.name,STATUS:.status.conditions[0].type,AGE:.metadata.creationTimestamp | tail -5
else
echo -e "${YELLOW}⚠️ Aucun Job trouvé (le CronJob n'a peut-être pas encore été exécuté)${NC}"
fi
echo ""
# 3. Vérifier les logs du dernier Job
echo "3. Logs du dernier Job..."
LAST_JOB=$(kubectl get jobs -n "$NAMESPACE" -l app=tls-sync-wildcard --context="$CONTEXT" --sort-by=.metadata.creationTimestamp -o jsonpath='{.items[-1].metadata.name}' 2>/dev/null)
if [ -n "$LAST_JOB" ]; then
echo " Job: $LAST_JOB"
echo ""
LOGS=$(kubectl logs -n "$NAMESPACE" job/"$LAST_JOB" --context="$CONTEXT" --tail=20 2>/dev/null)
if [ -n "$LOGS" ]; then
echo "$LOGS" | sed 's/^/ /'
# Vérifier les erreurs dans les logs
if echo "$LOGS" | grep -qi "error\|❌\|failed"; then
echo ""
echo -e "${RED}⚠️ Des erreurs ont été détectées dans les logs${NC}"
elif echo "$LOGS" | grep -qi "✅\|succès"; then
echo ""
echo -e "${GREEN}✅ Synchronisation réussie${NC}"
fi
else
echo -e "${YELLOW}⚠️ Aucun log disponible${NC}"
fi
else
echo -e "${YELLOW}⚠️ Aucun Job trouvé pour voir les logs${NC}"
fi
echo ""
# 4. Vérifier les secrets dans les clusters cibles
echo "4. Vérification des secrets synchronisés..."
# Cluster DEV
echo " Cluster DEV:"
for ns in headlamp-dev homarr-dev longhorn-dev; do
if kubectl get secret wildcard-dev-tls -n "$ns" --context=cluster-dev &>/dev/null; then
AGE=$(kubectl get secret wildcard-dev-tls -n "$ns" --context=cluster-dev -o jsonpath='{.metadata.creationTimestamp}' 2>/dev/null)
echo -e " ${GREEN}$ns${NC} (créé: $AGE)"
else
echo -e " ${RED}$ns: secret manquant${NC}"
fi
done
# Cluster RCT (si applicable)
if kubectl get secret wildcard-rct-tls -n certificates-ops --context="$CONTEXT" &>/dev/null; then
echo " Cluster RCT:"
for ns in headlamp-rct homarr-rct longhorn-rct; do
if kubectl get secret wildcard-rct-tls -n "$ns" --context=cluster-rct &>/dev/null; then
AGE=$(kubectl get secret wildcard-rct-tls -n "$ns" --context=cluster-rct -o jsonpath='{.metadata.creationTimestamp}' 2>/dev/null)
echo -e " ${GREEN}$ns${NC} (créé: $AGE)"
else
echo -e " ${RED}$ns: secret manquant${NC}"
fi
done
fi
# Cluster PRD (si applicable)
if kubectl get secret wildcard-prd-tls -n certificates-ops --context="$CONTEXT" &>/dev/null; then
echo " Cluster PRD:"
for ns in headlamp-prd homarr-prd longhorn-prd; do
if kubectl get secret wildcard-prd-tls -n "$ns" --context=cluster-prd &>/dev/null; then
AGE=$(kubectl get secret wildcard-prd-tls -n "$ns" --context=cluster-prd -o jsonpath='{.metadata.creationTimestamp}' 2>/dev/null)
echo -e " ${GREEN}$ns${NC} (créé: $AGE)"
else
echo -e " ${RED}$ns: secret manquant${NC}"
fi
done
fi
echo ""
# 5. Vérifier les ressources nécessaires
echo "5. Vérification des ressources..."
# ServiceAccount
if kubectl get serviceaccount tls-sync-wildcard -n "$NAMESPACE" --context="$CONTEXT" &>/dev/null; then
echo -e "${GREEN}✅ ServiceAccount existe${NC}"
else
echo -e "${RED}❌ ServiceAccount manquant${NC}"
fi
# ClusterRole
if kubectl get clusterrole tls-sync-wildcard --context="$CONTEXT" &>/dev/null; then
echo -e "${GREEN}✅ ClusterRole existe${NC}"
else
echo -e "${RED}❌ ClusterRole manquant${NC}"
fi
# ClusterRoleBinding
if kubectl get clusterrolebinding tls-sync-wildcard --context="$CONTEXT" &>/dev/null; then
echo -e "${GREEN}✅ ClusterRoleBinding existe${NC}"
else
echo -e "${RED}❌ ClusterRoleBinding manquant${NC}"
fi
# ConfigMap
if kubectl get configmap tls-sync-wildcard-script -n "$NAMESPACE" --context="$CONTEXT" &>/dev/null; then
echo -e "${GREEN}✅ ConfigMap existe${NC}"
else
echo -e "${RED}❌ ConfigMap manquant${NC}"
fi
# Secret kubeconfig
if kubectl get secret tls-sync-kubeconfig -n "$NAMESPACE" --context="$CONTEXT" &>/dev/null; then
echo -e "${GREEN}✅ Secret kubeconfig existe${NC}"
else
echo -e "${RED}❌ Secret kubeconfig manquant${NC}"
echo " Créez-le avec: kubectl create secret generic tls-sync-kubeconfig --from-file=config=\$HOME/.kube/config -n $NAMESPACE"
fi
echo ""
# 6. Résumé
echo "=== Résumé ==="
echo ""
echo "Pour déclencher une synchronisation manuelle:"
echo " kubectl create job --from=cronjob/tls-sync-wildcard tls-sync-wildcard-manual-\$(date +%s) -n $NAMESPACE --context=$CONTEXT"
echo ""
echo "Pour voir les logs en temps réel:"
echo " kubectl logs -n $NAMESPACE -l app=tls-sync-wildcard --context=$CONTEXT -f"
echo ""
echo "Pour plus de détails, consultez: helm/tls-sync-wildcard/ops/VÉRIFICATION.md"