# TLS Sync Wildcard - Synchronisation automatique des certificats wildcard

Ce chart Helm déploie un CronJob qui synchronise automatiquement les secrets TLS wildcard depuis le cluster OPS vers tous les namespaces qui en ont besoin dans les clusters DEV, RCT et PRD.

## Problème résolu

En Kubernetes, un Ingress ne peut référencer un secret TLS que s'il est dans le **même namespace** que l'Ingress. C'est une limitation de Kubernetes.

Pour les certificats wildcard utilisés par plusieurs applications dans différents namespaces, il faut donc copier le secret dans chaque namespace.

Ce CronJob automatise cette synchronisation.

## Installation

### 1. Créer le Secret avec le kubeconfig

Le CronJob a besoin d'accéder aux différents clusters. Créez un Secret contenant les kubeconfigs :

```bash
# Option 1 : En root Utiliser le kubeconfig par défaut (si tous les contextes sont dedans)
kubectl create secret generic tls-sync-kubeconfig \
  --from-file=config=$HOME/.kube/config \
  -n certificates-ops \
  --dry-run=client -o yaml | kubectl apply -f -

# Option 2 : Créer un kubeconfig combiné avec tous les contextes
kubectl config view --flatten > /tmp/combined-kubeconfig.yaml
kubectl create secret generic tls-sync-kubeconfig \
  --from-file=config=/tmp/combined-kubeconfig.yaml \
  -n certificates-ops \
  --dry-run=client -o yaml | kubectl apply -f -
```

**Important** : Assurez-vous que le fichier dans le Secret s'appelle `config` pour que kubectl le trouve automatiquement dans `/root/.kube/config`.

### 2. Créer le ConfigMap avec le script

Le script de synchronisation doit être disponible dans un ConfigMap :

```bash
kubectl create configmap tls-sync-wildcard-script \
  --from-file=sync-all-certificates.sh=../../scripts/sync-all-certificates.sh \
  -n certificates-ops \
  --dry-run=client -o yaml | kubectl apply -f -
```

### 3. Déployer via ArgoCD

Créez un ApplicationSet ou une Application ArgoCD pour déployer ce chart :

```yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: tls-sync-wildcard
  namespace: argocd-ops
spec:
  project: default
  source:
    repoURL: https://git.gkdomaine.fr/kubernetes/argocd.git
    targetRevision: main
    path: helm/tls-sync-wildcard/ops
  destination:
    name: cluster-ops
    namespace: certificates-ops
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true
```

### 4. Déploiement manuel (alternative)

```bash
helm install tls-sync-wildcard ./helm/tls-sync-wildcard/ops \
  -n certificates-ops \
  --create-namespace
```

## Configuration

### Modifier la fréquence de synchronisation

Éditez `helm/tls-sync-wildcard/ops/values.yaml` :

```yaml
tlsSync:
  schedule: "0 */2 * * *"  # Toutes les 2 heures
  # Autres exemples :
  # "0 * * * *"     - Toutes les heures
  # "*/30 * * * *"  - Toutes les 30 minutes
  # "0 0 * * *"     - Tous les jours à minuit
```

### Ajouter des namespaces cibles

Pour ajouter d'autres namespaces qui utilisent le certificat wildcard, modifiez la fonction `get_wildcard_target_namespaces` dans `scripts/sync-all-certificates.sh` :

```bash
case "$env" in
    dev)
        WILDCARD_TARGET_NAMESPACES=("headlamp-dev" "homarr-dev" "longhorn-dev" "autre-app-dev")
        ;;
    # ...
esac
```

## Vérification

```bash
# Vérifier le CronJob
kubectl get cronjob -n certificates-ops tls-sync-wildcard

# Vérifier les Jobs créés
kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard

# Voir les logs du dernier Job
kubectl logs -n certificates-ops -l app=tls-sync-wildcard --tail=100

# Déclencher manuellement une synchronisation
kubectl create job --from=cronjob/tls-sync-wildcard tls-sync-wildcard-manual-$(date +%s) -n certificates-ops
```

## Dépannage

### Le CronJob ne se déclenche pas

```bash
# Vérifier le schedule
kubectl get cronjob tls-sync-wildcard -n certificates-ops -o yaml | grep schedule

# Vérifier les événements
kubectl get events -n certificates-ops --sort-by='.lastTimestamp' | grep tls-sync-wildcard
```

### Les Jobs échouent

```bash
# Voir les logs du dernier Job
kubectl logs -n certificates-ops -l app=tls-sync-wildcard --tail=100

# Vérifier les erreurs
kubectl describe job -n certificates-ops -l app=tls-sync-wildcard
```

### Erreur "context not found"

Le Secret `tls-sync-kubeconfig` n'est pas correctement configuré ou les contextes kubectl ne sont pas disponibles.

```bash
# Vérifier le Secret
kubectl get secret tls-sync-kubeconfig -n certificates-ops -o yaml

# Tester l'accès depuis un pod
kubectl run -it --rm debug --image=bitnami/kubectl:1.31 --restart=Never \
  -n certificates-ops \
  --overrides='
{
  "spec": {
    "containers": [{
      "name": "debug",
      "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
```

## Architecture

```
┌─────────────────┐
│  Cluster OPS    │
│                 │
│  cert-manager   │─── Génère les certificats Let's Encrypt
│                 │
│  Certificates   │─── Crée les secrets TLS dans certificates-ops
│                 │
│  CronJob        │─── Synchronise automatiquement les secrets
│  tls-sync-      │    wildcard vers tous les namespaces nécessaires
│  wildcard       │
└─────────────────┘
         │
         ├───► Cluster DEV
         │     ├─── headlamp-dev (wildcard-dev-tls)
         │     ├─── homarr-dev (wildcard-dev-tls)
         │     └─── longhorn-dev (wildcard-dev-tls)
         │
         ├───► Cluster RCT
         │     └─── (même principe)
         │
         └───► Cluster PRD
               └─── (même principe)
```