Files

Melvin GABALI 2e0b425939 update sync tls

2026-01-22 02:34:41 +01:00

9.3 KiB

Raw Blame History

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é

# 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

# 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

# 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

# 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

# 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

# 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

# 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

# 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

# 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 :

#!/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

# 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

# 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

# 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"

# 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 :

# 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

# 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

9.3 KiB Raw Blame History