add tls sync
This commit is contained in:
@@ -1,49 +0,0 @@
|
||||
apiVersion: argoproj.io/v1alpha1
|
||||
kind: ApplicationSet
|
||||
metadata:
|
||||
name: tls-secrets-sync
|
||||
namespace: argocd-ops
|
||||
spec:
|
||||
generators:
|
||||
# Génère une application pour chaque secret TLS à synchroniser
|
||||
# depuis OPS vers les clusters DEV, RCT, PRD
|
||||
- list:
|
||||
elements:
|
||||
# Homarr DEV : synchroniser depuis OPS vers DEV
|
||||
- app: homarr
|
||||
env: dev
|
||||
secretName: homarr-dev-tls
|
||||
sourceNamespace: certificates-ops
|
||||
sourceCluster: cluster-ops
|
||||
targetNamespace: homarr-dev
|
||||
targetCluster: cluster-dev
|
||||
template:
|
||||
metadata:
|
||||
name: 'tls-secret-sync-{{app}}-{{env}}'
|
||||
spec:
|
||||
project: default
|
||||
source:
|
||||
repoURL: https://git.gkdomaine.fr/kubernetes/argocd.git
|
||||
targetRevision: main
|
||||
path: helm/tls-secrets-sync/ops
|
||||
helm:
|
||||
valueFiles:
|
||||
- values.yaml
|
||||
values: |
|
||||
app: {{app}}
|
||||
env: {{env}}
|
||||
secretName: {{secretName}}
|
||||
sourceNamespace: {{sourceNamespace}}
|
||||
sourceCluster: {{sourceCluster}}
|
||||
targetNamespace: {{targetNamespace}}
|
||||
targetCluster: {{targetCluster}}
|
||||
destination:
|
||||
# Les Jobs de synchronisation s'exécutent dans OPS
|
||||
name: '{{sourceCluster}}'
|
||||
namespace: '{{sourceNamespace}}'
|
||||
syncPolicy:
|
||||
automated:
|
||||
prune: true
|
||||
selfHeal: true
|
||||
syncOptions:
|
||||
- CreateNamespace=true
|
||||
44
apps/applicationset-tls-sync.yaml
Normal file
44
apps/applicationset-tls-sync.yaml
Normal file
@@ -0,0 +1,44 @@
|
||||
apiVersion: argoproj.io/v1alpha1
|
||||
kind: ApplicationSet
|
||||
metadata:
|
||||
name: tls-sync
|
||||
namespace: argocd-ops
|
||||
spec:
|
||||
generators:
|
||||
# Le CronJob de synchronisation TLS est déployé UNIQUEMENT sur le cluster OPS
|
||||
- merge:
|
||||
generators:
|
||||
# Premier générateur : scanne les répertoires Helm pour tls-sync
|
||||
- git:
|
||||
repoURL: https://git.gkdomaine.fr/kubernetes/argocd.git
|
||||
revision: main
|
||||
directories:
|
||||
- path: "helm/tls-sync/*"
|
||||
# Deuxième générateur : lit la config OPS uniquement
|
||||
- git:
|
||||
repoURL: https://git.gkdomaine.fr/kubernetes/argocd.git
|
||||
revision: main
|
||||
files:
|
||||
- path: "configs/ops/config.json"
|
||||
mergeKeys:
|
||||
- path.basename
|
||||
template:
|
||||
metadata:
|
||||
name: 'tls-sync-{{path.basename}}'
|
||||
spec:
|
||||
project: default
|
||||
source:
|
||||
repoURL: '{{repository}}'
|
||||
targetRevision: '{{targetRevision}}'
|
||||
path: '{{helmPath}}/tls-sync/{{path.basename}}'
|
||||
destination:
|
||||
# Déploie uniquement sur le cluster OPS
|
||||
name: '{{name}}'
|
||||
namespace: certificates-{{path.basename}}
|
||||
syncPolicy:
|
||||
automated:
|
||||
prune: true
|
||||
selfHeal: true
|
||||
syncOptions:
|
||||
- CreateNamespace=true
|
||||
|
||||
270
docs/AUTOMATISATION-SYNC-TLS.md
Normal file
270
docs/AUTOMATISATION-SYNC-TLS.md
Normal file
@@ -0,0 +1,270 @@
|
||||
# Automatisation de la Synchronisation des Secrets TLS
|
||||
|
||||
## Vue d'ensemble
|
||||
|
||||
Ce document décrit les différentes options pour automatiser la synchronisation des secrets TLS depuis le cluster OPS (où cert-manager génère les certificats) vers les clusters DEV, RCT et PRD (où les applications sont déployées).
|
||||
|
||||
## 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 │ vers les autres clusters
|
||||
└─────────────────┘
|
||||
│
|
||||
├───► Cluster DEV (homarr-dev, headlamp-dev, etc.)
|
||||
├───► Cluster RCT (applications RCT)
|
||||
└───► Cluster PRD (applications PRD)
|
||||
```
|
||||
|
||||
## Solution Implémentée : CronJob Kubernetes
|
||||
|
||||
### Avantages
|
||||
|
||||
✅ **Simple et fiable** : Utilise les ressources Kubernetes natives
|
||||
✅ **GitOps compatible** : Déployé via ArgoCD depuis Git
|
||||
✅ **Facile à déboguer** : Logs disponibles via `kubectl logs`
|
||||
✅ **Configurable** : Fréquence de synchronisation ajustable
|
||||
✅ **Robuste** : Gestion automatique des erreurs et retry
|
||||
|
||||
### Inconvénients
|
||||
|
||||
⚠️ **Délai de synchronisation** : Maximum 1 heure (selon la fréquence configurée)
|
||||
⚠️ **Nécessite les kubeconfigs** : Les contextes kubectl doivent être disponibles dans le pod
|
||||
|
||||
## Installation
|
||||
|
||||
### 1. Créer le Secret avec les kubeconfigs
|
||||
|
||||
Le CronJob a besoin d'accéder aux différents clusters. Créez un Secret contenant les kubeconfigs :
|
||||
|
||||
```bash
|
||||
# Option 1 : Utiliser le kubeconfig par défaut (si tous les contextes sont dedans)
|
||||
kubectl create secret generic tls-sync-kubeconfig \
|
||||
--from-file=config=/root/.kube/config \
|
||||
-n certificates-ops \
|
||||
--dry-run=client -o yaml | kubectl apply -f -
|
||||
|
||||
# Option 2 : Créer un kubeconfig combiné avec tous les contextes
|
||||
# (recommandé si vous avez plusieurs fichiers kubeconfig)
|
||||
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. Déployer via ArgoCD
|
||||
|
||||
Le chart Helm est déjà configuré dans `apps/applicationset-tls-sync.yaml`. ArgoCD le déploiera automatiquement sur le cluster OPS.
|
||||
|
||||
Si vous préférez déployer manuellement :
|
||||
|
||||
```bash
|
||||
helm install tls-sync ./helm/tls-sync/ops \
|
||||
-n certificates-ops \
|
||||
--create-namespace
|
||||
```
|
||||
|
||||
### 3. Vérifier le déploiement
|
||||
|
||||
```bash
|
||||
# Vérifier le CronJob
|
||||
kubectl get cronjob -n certificates-ops
|
||||
|
||||
# Vérifier les Jobs créés
|
||||
kubectl get jobs -n certificates-ops -l app=tls-sync
|
||||
|
||||
# Voir les logs du dernier Job
|
||||
kubectl logs -n certificates-ops -l app=tls-sync --tail=100
|
||||
|
||||
# Déclencher manuellement une synchronisation
|
||||
kubectl create job --from=cronjob/tls-sync tls-sync-manual-$(date +%s) -n certificates-ops
|
||||
```
|
||||
|
||||
## Configuration
|
||||
|
||||
### Modifier la fréquence de synchronisation
|
||||
|
||||
Éditez `helm/tls-sync/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
|
||||
```
|
||||
|
||||
### Modifier les ressources
|
||||
|
||||
```yaml
|
||||
tlsSync:
|
||||
resources:
|
||||
requests:
|
||||
memory: "128Mi"
|
||||
cpu: "100m"
|
||||
limits:
|
||||
memory: "256Mi"
|
||||
cpu: "500m"
|
||||
```
|
||||
|
||||
## Alternatives
|
||||
|
||||
### Option 1 : Watch/Webhook (Réactif)
|
||||
|
||||
Utiliser un opérateur Kubernetes qui surveille les changements de secrets et synchronise immédiatement.
|
||||
|
||||
**Avantages** :
|
||||
- Synchronisation instantanée
|
||||
- Réactif aux changements
|
||||
|
||||
**Inconvénients** :
|
||||
- Plus complexe à mettre en place
|
||||
- Nécessite un opérateur personnalisé ou External Secrets Operator
|
||||
- Plus de ressources consommées
|
||||
|
||||
### Option 2 : External Secrets Operator
|
||||
|
||||
Utiliser ESO pour synchroniser les secrets depuis un backend (comme Kubernetes secrets dans OPS).
|
||||
|
||||
**Avantages** :
|
||||
- Solution standardisée
|
||||
- Support multi-cluster natif
|
||||
|
||||
**Inconvénients** :
|
||||
- Nécessite d'installer ESO sur tous les clusters
|
||||
- Configuration plus complexe
|
||||
- Overhead supplémentaire
|
||||
|
||||
### Option 3 : ArgoCD Application (GitOps)
|
||||
|
||||
Créer des Applications ArgoCD qui référencent les secrets TLS depuis OPS.
|
||||
|
||||
**Avantages** :
|
||||
- Complètement GitOps
|
||||
- Intégré avec ArgoCD
|
||||
|
||||
**Inconvénients** :
|
||||
- Les secrets ne sont pas dans Git (contraire aux pratiques GitOps)
|
||||
- Nécessite une configuration complexe avec des secrets externes
|
||||
|
||||
## Dépannage
|
||||
|
||||
### Le CronJob ne se déclenche pas
|
||||
|
||||
```bash
|
||||
# Vérifier le schedule
|
||||
kubectl get cronjob tls-sync -n certificates-ops -o yaml | grep schedule
|
||||
|
||||
# Vérifier les événements
|
||||
kubectl get events -n certificates-ops --sort-by='.lastTimestamp' | grep tls-sync
|
||||
```
|
||||
|
||||
### Les Jobs échouent
|
||||
|
||||
```bash
|
||||
# Voir les logs du dernier Job
|
||||
kubectl logs -n certificates-ops -l app=tls-sync --tail=100
|
||||
|
||||
# Vérifier les erreurs
|
||||
kubectl describe job -n certificates-ops -l app=tls-sync
|
||||
```
|
||||
|
||||
### 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 \
|
||||
--overrides='
|
||||
{
|
||||
"spec": {
|
||||
"containers": [{
|
||||
"name": "debug",
|
||||
"image": "bitnami/kubectl:1.31",
|
||||
"command": ["/bin/sh"],
|
||||
"args": ["-c", "sleep 3600"],
|
||||
"volumeMounts": [{
|
||||
"name": "kubeconfig",
|
||||
"mountPath": "/root/.kube"
|
||||
}]
|
||||
}],
|
||||
"volumes": [{
|
||||
"name": "kubeconfig",
|
||||
"secret": {
|
||||
"secretName": "tls-sync-kubeconfig"
|
||||
}
|
||||
}]
|
||||
}
|
||||
}' -n certificates-ops
|
||||
|
||||
# Dans le pod, tester :
|
||||
kubectl config get-contexts
|
||||
kubectl get nodes --context=cluster-dev
|
||||
```
|
||||
|
||||
### Les secrets ne sont pas synchronisés
|
||||
|
||||
1. Vérifier que les certificats existent dans OPS :
|
||||
```bash
|
||||
kubectl get certificates -n certificates-ops
|
||||
```
|
||||
|
||||
2. Vérifier que les secrets TLS existent dans OPS :
|
||||
```bash
|
||||
kubectl get secrets -n certificates-ops | grep tls
|
||||
```
|
||||
|
||||
3. Vérifier que les contextes kubectl sont corrects :
|
||||
```bash
|
||||
kubectl config get-contexts
|
||||
```
|
||||
|
||||
4. Vérifier les logs du Job pour voir les erreurs spécifiques
|
||||
|
||||
## Monitoring
|
||||
|
||||
### Vérifier l'historique des synchronisations
|
||||
|
||||
```bash
|
||||
# Voir tous les Jobs créés par le CronJob
|
||||
kubectl get jobs -n certificates-ops -l app=tls-sync --sort-by=.metadata.creationTimestamp
|
||||
|
||||
# Voir les logs de tous les Jobs réussis
|
||||
for job in $(kubectl get jobs -n certificates-ops -l app=tls-sync -o name | grep -v "No resources"); do
|
||||
echo "=== $job ==="
|
||||
kubectl logs -n certificates-ops $job
|
||||
done
|
||||
```
|
||||
|
||||
### Alertes (optionnel)
|
||||
|
||||
Vous pouvez créer des alertes Prometheus pour surveiller :
|
||||
- Le nombre de Jobs échoués
|
||||
- La durée d'exécution des Jobs
|
||||
- Le nombre de secrets synchronisés
|
||||
|
||||
## Conclusion
|
||||
|
||||
La solution CronJob est recommandée car elle est :
|
||||
- ✅ Simple à mettre en place
|
||||
- ✅ Fiable et robuste
|
||||
- ✅ Compatible avec GitOps
|
||||
- ✅ Facile à maintenir et déboguer
|
||||
|
||||
Pour la plupart des cas d'usage, une synchronisation toutes les heures est suffisante, car les certificats Let's Encrypt sont valides pendant 90 jours et sont renouvelés automatiquement 30 jours avant expiration.
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
apiVersion: v2
|
||||
name: tls-secrets-sync
|
||||
description: Synchronisation des secrets TLS depuis OPS vers les autres clusters
|
||||
type: application
|
||||
version: 1.0.0
|
||||
@@ -1,50 +0,0 @@
|
||||
# Synchronisation des Secrets TLS
|
||||
|
||||
Ce chart gère la synchronisation des secrets TLS depuis le cluster OPS vers les autres clusters (DEV, RCT, PRD).
|
||||
|
||||
## Structure
|
||||
|
||||
- `Chart.yaml` : Définition du chart Helm
|
||||
- `values.yaml` : Configuration par défaut
|
||||
- `templates/` : Templates Kubernetes
|
||||
- `namespace-certificates.yaml` : Namespace pour les certificats sur OPS
|
||||
- `secret-*.yaml` : Secrets de référence (optionnel)
|
||||
- `sync-job-*.yaml` : Jobs de synchronisation
|
||||
- `rbac-secret-sync.yaml` : RBAC pour les Jobs
|
||||
|
||||
## Utilisation
|
||||
|
||||
### Option 1 : Synchronisation manuelle via script (Recommandée)
|
||||
|
||||
Utilisez le script `scripts/sync-tls-secret.sh` :
|
||||
|
||||
```bash
|
||||
./scripts/sync-tls-secret.sh homarr-dev-tls cluster-ops certificates-ops cluster-dev homarr-dev
|
||||
```
|
||||
|
||||
### Option 2 : Synchronisation automatique via Jobs
|
||||
|
||||
Les Jobs Kubernetes tentent de synchroniser automatiquement, mais nécessitent que les contextes kubectl soient configurés dans le pod.
|
||||
|
||||
### Option 3 : Synchronisation via CronJob
|
||||
|
||||
Créez un CronJob qui exécute le script de synchronisation périodiquement.
|
||||
|
||||
## Configuration
|
||||
|
||||
Les secrets sont synchronisés depuis :
|
||||
- **Source** : Namespace `certificates-ops` sur cluster OPS
|
||||
- **Destination** : Namespaces des applications sur clusters DEV/RCT/PRD
|
||||
|
||||
## Ajout d'un nouveau secret à synchroniser
|
||||
|
||||
1. Ajoutez une entrée dans `apps/applicationset-tls-secrets-sync.yaml`
|
||||
2. Créez un template `sync-job-<app>-<env>.yaml` si nécessaire
|
||||
3. Ou utilisez directement le script `sync-tls-secret.sh`
|
||||
|
||||
## Notes importantes
|
||||
|
||||
- Les contextes kubectl doivent être configurés pour accéder aux différents clusters
|
||||
- Le namespace de destination doit exister sur le cluster cible
|
||||
- Les secrets sont copiés avec leurs données, mais les métadonnées sont nettoyées
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
apiVersion: v1
|
||||
kind: Namespace
|
||||
metadata:
|
||||
name: certificates-ops
|
||||
labels:
|
||||
name: certificates-ops
|
||||
managed-by: argocd
|
||||
purpose: tls-certificates
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
apiVersion: v1
|
||||
kind: Secret
|
||||
metadata:
|
||||
name: homarr-dev-tls
|
||||
namespace: homarr-dev
|
||||
labels:
|
||||
app: homarr
|
||||
environment: dev
|
||||
managed-by: argocd
|
||||
source-cluster: ops
|
||||
source-namespace: certificates-ops
|
||||
type: kubernetes.io/tls
|
||||
# Les données seront copiées depuis le secret dans OPS
|
||||
# Ce template sert de référence - le secret réel sera synchronisé via un Job ou script
|
||||
data: {}
|
||||
|
||||
@@ -1,66 +0,0 @@
|
||||
apiVersion: batch/v1
|
||||
kind: Job
|
||||
metadata:
|
||||
name: sync-tls-secret-homarr-dev
|
||||
namespace: certificates-ops
|
||||
annotations:
|
||||
argocd.argoproj.io/hook: Sync
|
||||
argocd.argoproj.io/hook-delete-policy: BeforeHookCreation
|
||||
spec:
|
||||
template:
|
||||
spec:
|
||||
serviceAccountName: secret-sync-sa
|
||||
containers:
|
||||
- name: kubectl
|
||||
image: bitnami/kubectl:latest
|
||||
command:
|
||||
- /bin/sh
|
||||
- -c
|
||||
- |
|
||||
set -e
|
||||
echo "=== Synchronisation du secret TLS homarr-dev-tls ==="
|
||||
echo "Source: cluster-ops, namespace: certificates-ops"
|
||||
echo "Destination: cluster-dev, namespace: homarr-dev"
|
||||
|
||||
# Récupérer le secret depuis OPS (cluster actuel)
|
||||
echo "1. Récupération du secret depuis OPS..."
|
||||
kubectl get secret homarr-dev-tls -n certificates-ops -o yaml > /tmp/secret-source.yaml
|
||||
|
||||
if [ ! -s /tmp/secret-source.yaml ]; then
|
||||
echo "❌ Erreur: Le secret homarr-dev-tls n'existe pas dans certificates-ops sur OPS"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Modifier les métadonnées pour la destination
|
||||
echo "2. Préparation du secret pour DEV..."
|
||||
cat /tmp/secret-source.yaml | \
|
||||
sed '/^ uid:/d' | \
|
||||
sed '/^ resourceVersion:/d' | \
|
||||
sed '/^ selfLink:/d' | \
|
||||
sed '/^ creationTimestamp:/d' | \
|
||||
sed 's/namespace: certificates-ops/namespace: homarr-dev/' > /tmp/secret-dest.yaml
|
||||
|
||||
# Appliquer le secret sur DEV
|
||||
# Note: Cela nécessite que kubectl soit configuré avec les contextes des clusters
|
||||
echo "3. Application du secret sur DEV..."
|
||||
|
||||
# Vérifier si le contexte cluster-dev existe
|
||||
if kubectl config get-contexts cluster-dev &>/dev/null; then
|
||||
# Créer le namespace s'il n'existe pas
|
||||
kubectl create namespace homarr-dev --context=cluster-dev --dry-run=client -o yaml | kubectl apply --context=cluster-dev -f - || true
|
||||
|
||||
# Appliquer le secret
|
||||
kubectl apply -f /tmp/secret-dest.yaml --context=cluster-dev
|
||||
|
||||
echo "✅ Secret synchronisé vers cluster-dev"
|
||||
else
|
||||
echo "⚠️ Le contexte cluster-dev n'est pas configuré dans kubectl"
|
||||
echo " Pour synchroniser manuellement, exécutez :"
|
||||
echo " kubectl apply -f /tmp/secret-dest.yaml --context=cluster-dev"
|
||||
echo ""
|
||||
echo " Ou utilisez le script :"
|
||||
echo " ./scripts/sync-tls-secret.sh homarr-dev-tls cluster-ops certificates-ops cluster-dev homarr-dev"
|
||||
fi
|
||||
restartPolicy: Never
|
||||
backoffLimit: 3
|
||||
|
||||
@@ -1,8 +0,0 @@
|
||||
# Valeurs par défaut - seront surchargées par l'ApplicationSet
|
||||
app: homarr
|
||||
env: dev
|
||||
secretName: homarr-dev-tls
|
||||
sourceNamespace: certificates-ops
|
||||
sourceCluster: cluster-ops
|
||||
targetNamespace: homarr-dev
|
||||
targetCluster: cluster-dev
|
||||
7
helm/tls-sync/ops/Chart.yaml
Normal file
7
helm/tls-sync/ops/Chart.yaml
Normal file
@@ -0,0 +1,7 @@
|
||||
apiVersion: v2
|
||||
name: tls-sync
|
||||
description: Chart pour synchroniser automatiquement les secrets TLS depuis OPS vers les autres clusters
|
||||
type: application
|
||||
version: 1.0.0
|
||||
appVersion: "1.0.0"
|
||||
|
||||
176
helm/tls-sync/ops/templates/configmap-script.yaml
Normal file
176
helm/tls-sync/ops/templates/configmap-script.yaml
Normal file
@@ -0,0 +1,176 @@
|
||||
apiVersion: v1
|
||||
kind: ConfigMap
|
||||
metadata:
|
||||
name: tls-sync-script
|
||||
namespace: {{ .Release.Namespace }}
|
||||
data:
|
||||
sync-all-certificates.sh: |
|
||||
#!/bin/bash
|
||||
# Script pour synchroniser automatiquement tous les secrets TLS depuis les certificats dans OPS
|
||||
# Ce script est exécuté dans un CronJob Kubernetes
|
||||
|
||||
set -e
|
||||
|
||||
SOURCE_NS="${SOURCE_NS:-{{ .Values.tlsSync.sourceNamespace }}}"
|
||||
|
||||
echo "=== Synchronisation automatique des secrets TLS ==="
|
||||
echo "Source: namespace $SOURCE_NS (cluster OPS)"
|
||||
echo "Date: $(date)"
|
||||
echo ""
|
||||
|
||||
# Fonction pour déterminer le cluster et namespace cible à partir du nom du certificat
|
||||
determine_target() {
|
||||
local cert_name=$1
|
||||
|
||||
if [[ $cert_name =~ -dev-tls$ ]]; then
|
||||
TARGET_CLUSTER="cluster-dev"
|
||||
TARGET_NS="${cert_name%-tls}"
|
||||
elif [[ $cert_name =~ -rct-tls$ ]]; then
|
||||
TARGET_CLUSTER="cluster-rct"
|
||||
TARGET_NS="${cert_name%-tls}"
|
||||
elif [[ $cert_name =~ -prd-tls$ ]]; then
|
||||
TARGET_CLUSTER="cluster-prd"
|
||||
TARGET_NS="${cert_name%-tls}"
|
||||
else
|
||||
if [[ $cert_name == *"dev"* ]]; then
|
||||
TARGET_CLUSTER="cluster-dev"
|
||||
TARGET_NS="${cert_name%-tls}"
|
||||
else
|
||||
echo "⚠️ Impossible de déterminer le cluster cible pour $cert_name"
|
||||
return 1
|
||||
fi
|
||||
fi
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Vérifier l'accès au cluster OPS (in-cluster)
|
||||
echo "1. Vérification de l'accès au cluster OPS..."
|
||||
if ! kubectl get nodes &>/dev/null; then
|
||||
echo "❌ Erreur: Impossible d'accéder au cluster OPS"
|
||||
exit 1
|
||||
fi
|
||||
echo " ✅ Accès au cluster OPS confirmé"
|
||||
|
||||
# Récupérer tous les certificats
|
||||
echo "2. Récupération des certificats depuis $SOURCE_NS..."
|
||||
CERTIFICATES=$(kubectl get certificates -n "$SOURCE_NS" -o json 2>&1)
|
||||
KUBECTL_EXIT_CODE=$?
|
||||
|
||||
if [ $KUBECTL_EXIT_CODE -ne 0 ]; then
|
||||
echo "❌ Erreur lors de la récupération des certificats:"
|
||||
echo "$CERTIFICATES" | head -5
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Vérifier que jq est disponible
|
||||
if ! command -v jq &> /dev/null; then
|
||||
echo "❌ Erreur: jq n'est pas disponible dans le conteneur"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
CERT_COUNT=$(echo "$CERTIFICATES" | jq -r '.items | length' 2>/dev/null)
|
||||
if [ -z "$CERT_COUNT" ] || [ "$CERT_COUNT" == "null" ] || [ "$CERT_COUNT" == "0" ]; then
|
||||
echo "⚠️ Aucun certificat trouvé dans $SOURCE_NS"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
echo " Trouvé $CERT_COUNT certificat(s)"
|
||||
echo ""
|
||||
|
||||
# Traiter chaque certificat
|
||||
SUCCESS_COUNT=0
|
||||
SKIP_COUNT=0
|
||||
ERROR_COUNT=0
|
||||
|
||||
for i in $(seq 0 $((CERT_COUNT - 1))); do
|
||||
CERT_NAME=$(echo "$CERTIFICATES" | jq -r ".items[$i].metadata.name")
|
||||
SECRET_NAME=$(echo "$CERTIFICATES" | jq -r ".items[$i].spec.secretName")
|
||||
CERT_NAMESPACE=$(echo "$CERTIFICATES" | jq -r ".items[$i].metadata.namespace")
|
||||
|
||||
if [ "$SECRET_NAME" == "null" ] || [ -z "$SECRET_NAME" ]; then
|
||||
SECRET_NAME="$CERT_NAME"
|
||||
fi
|
||||
|
||||
echo "📋 Traitement du certificat: $CERT_NAME"
|
||||
echo " Secret: $SECRET_NAME"
|
||||
|
||||
# Déterminer le cluster et namespace cible
|
||||
if ! determine_target "$CERT_NAME"; then
|
||||
echo " ⚠️ Ignoré (impossible de déterminer la destination)"
|
||||
SKIP_COUNT=$((SKIP_COUNT + 1))
|
||||
echo ""
|
||||
continue
|
||||
fi
|
||||
|
||||
echo " Destination: $TARGET_CLUSTER (namespace: $TARGET_NS)"
|
||||
|
||||
# Vérifier que le secret existe dans la source
|
||||
if ! kubectl get secret "$SECRET_NAME" -n "$SOURCE_NS" &>/dev/null; then
|
||||
echo " ⚠️ Le secret $SECRET_NAME n'existe pas encore (certificat peut-être en cours de génération)"
|
||||
SKIP_COUNT=$((SKIP_COUNT + 1))
|
||||
echo ""
|
||||
continue
|
||||
fi
|
||||
|
||||
# Synchroniser le secret
|
||||
echo " Synchronisation en cours..."
|
||||
|
||||
# Récupérer le secret
|
||||
TEMP_FILE=$(mktemp)
|
||||
if ! kubectl get secret "$SECRET_NAME" -n "$SOURCE_NS" -o yaml > "$TEMP_FILE" 2>/dev/null; then
|
||||
echo " ❌ Erreur: Impossible de récupérer le secret"
|
||||
rm -f "$TEMP_FILE"
|
||||
ERROR_COUNT=$((ERROR_COUNT + 1))
|
||||
echo ""
|
||||
continue
|
||||
fi
|
||||
|
||||
# Modifier les métadonnées
|
||||
sed -i '/^ uid:/d' "$TEMP_FILE" 2>/dev/null || true
|
||||
sed -i '/^ resourceVersion:/d' "$TEMP_FILE" 2>/dev/null || true
|
||||
sed -i '/^ selfLink:/d' "$TEMP_FILE" 2>/dev/null || true
|
||||
sed -i '/^ creationTimestamp:/d' "$TEMP_FILE" 2>/dev/null || true
|
||||
sed -i "s/namespace: $SOURCE_NS/namespace: $TARGET_NS/" "$TEMP_FILE" 2>/dev/null || true
|
||||
|
||||
# Créer le namespace s'il n'existe pas
|
||||
kubectl create namespace "$TARGET_NS" --context="$TARGET_CLUSTER" --dry-run=client -o yaml | kubectl apply --context="$TARGET_CLUSTER" -f - >/dev/null 2>&1 || true
|
||||
|
||||
# Appliquer le secret
|
||||
if kubectl apply -f "$TEMP_FILE" --context="$TARGET_CLUSTER" >/dev/null 2>&1; then
|
||||
if kubectl get secret "$SECRET_NAME" -n "$TARGET_NS" --context="$TARGET_CLUSTER" >/dev/null 2>&1; then
|
||||
echo " ✅ Synchronisé avec succès"
|
||||
SUCCESS_COUNT=$((SUCCESS_COUNT + 1))
|
||||
else
|
||||
echo " ❌ Erreur: Le secret n'a pas été créé"
|
||||
ERROR_COUNT=$((ERROR_COUNT + 1))
|
||||
fi
|
||||
else
|
||||
echo " ❌ Erreur lors de l'application du secret"
|
||||
ERROR_COUNT=$((ERROR_COUNT + 1))
|
||||
fi
|
||||
|
||||
# Nettoyage
|
||||
rm -f "$TEMP_FILE" 2>/dev/null || true
|
||||
|
||||
echo ""
|
||||
done
|
||||
|
||||
# Résumé
|
||||
echo "=== Résumé ==="
|
||||
echo "✅ Synchronisés avec succès: $SUCCESS_COUNT"
|
||||
echo "⚠️ Ignorés: $SKIP_COUNT"
|
||||
echo "❌ Erreurs: $ERROR_COUNT"
|
||||
echo ""
|
||||
|
||||
if [ $ERROR_COUNT -eq 0 ] && [ $SUCCESS_COUNT -gt 0 ]; then
|
||||
echo "🎉 Toutes les synchronisations réussies !"
|
||||
exit 0
|
||||
elif [ $ERROR_COUNT -gt 0 ]; then
|
||||
echo "⚠️ Certaines synchronisations ont échoué"
|
||||
exit 1
|
||||
else
|
||||
echo "ℹ️ Aucune synchronisation effectuée"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
62
helm/tls-sync/ops/templates/cronjob.yaml
Normal file
62
helm/tls-sync/ops/templates/cronjob.yaml
Normal file
@@ -0,0 +1,62 @@
|
||||
apiVersion: batch/v1
|
||||
kind: CronJob
|
||||
metadata:
|
||||
name: tls-sync
|
||||
namespace: {{ .Release.Namespace }}
|
||||
spec:
|
||||
schedule: {{ .Values.tlsSync.schedule | quote }}
|
||||
concurrencyPolicy: {{ .Values.tlsSync.concurrencyPolicy }}
|
||||
successfulJobsHistoryLimit: {{ .Values.tlsSync.successfulJobsHistoryLimit }}
|
||||
failedJobsHistoryLimit: {{ .Values.tlsSync.failedJobsHistoryLimit }}
|
||||
jobTemplate:
|
||||
spec:
|
||||
activeDeadlineSeconds: {{ .Values.tlsSync.jobTimeout }}
|
||||
backoffLimit: 2
|
||||
template:
|
||||
metadata:
|
||||
labels:
|
||||
app: tls-sync
|
||||
spec:
|
||||
serviceAccountName: tls-sync
|
||||
restartPolicy: OnFailure
|
||||
containers:
|
||||
- name: sync
|
||||
image: {{ .Values.tlsSync.image.repository }}:{{ .Values.tlsSync.image.tag }}
|
||||
imagePullPolicy: {{ .Values.tlsSync.image.pullPolicy }}
|
||||
command:
|
||||
- /bin/bash
|
||||
- -c
|
||||
- |
|
||||
# Installer jq si nécessaire (l'image bitnami/kubectl ne contient pas jq)
|
||||
if ! command -v jq &> /dev/null; then
|
||||
echo "Installation de jq..."
|
||||
apk add --no-cache jq 2>/dev/null || \
|
||||
(apt-get update && apt-get install -y jq 2>/dev/null) || \
|
||||
(yum install -y jq 2>/dev/null) || \
|
||||
(echo "⚠️ Impossible d'installer jq" && exit 1)
|
||||
fi
|
||||
|
||||
# Exécuter le script de synchronisation
|
||||
/scripts/sync-all-certificates.sh
|
||||
env:
|
||||
- name: SOURCE_NS
|
||||
value: {{ .Values.tlsSync.sourceNamespace | quote }}
|
||||
volumeMounts:
|
||||
- name: sync-script
|
||||
mountPath: /scripts
|
||||
readOnly: true
|
||||
- name: kubeconfig
|
||||
mountPath: /root/.kube
|
||||
readOnly: true
|
||||
resources:
|
||||
{{- toYaml .Values.tlsSync.resources | nindent 14 }}
|
||||
volumes:
|
||||
- name: sync-script
|
||||
configMap:
|
||||
name: tls-sync-script
|
||||
defaultMode: 0755
|
||||
- name: kubeconfig
|
||||
secret:
|
||||
secretName: tls-sync-kubeconfig
|
||||
optional: true
|
||||
|
||||
@@ -1,15 +1,18 @@
|
||||
apiVersion: v1
|
||||
kind: ServiceAccount
|
||||
metadata:
|
||||
name: secret-sync-sa
|
||||
namespace: certificates-ops
|
||||
name: tls-sync
|
||||
namespace: {{ .Release.Namespace }}
|
||||
---
|
||||
apiVersion: rbac.authorization.k8s.io/v1
|
||||
kind: Role
|
||||
metadata:
|
||||
name: secret-sync-role
|
||||
namespace: certificates-ops
|
||||
name: tls-sync-role
|
||||
namespace: {{ .Release.Namespace }}
|
||||
rules:
|
||||
- apiGroups: ["cert-manager.io"]
|
||||
resources: ["certificates"]
|
||||
verbs: ["get", "list"]
|
||||
- apiGroups: [""]
|
||||
resources: ["secrets"]
|
||||
verbs: ["get", "list"]
|
||||
@@ -17,14 +20,14 @@ rules:
|
||||
apiVersion: rbac.authorization.k8s.io/v1
|
||||
kind: RoleBinding
|
||||
metadata:
|
||||
name: secret-sync-rolebinding
|
||||
namespace: certificates-ops
|
||||
name: tls-sync-rolebinding
|
||||
namespace: {{ .Release.Namespace }}
|
||||
roleRef:
|
||||
apiGroup: rbac.authorization.k8s.io
|
||||
kind: Role
|
||||
name: secret-sync-role
|
||||
name: tls-sync-role
|
||||
subjects:
|
||||
- kind: ServiceAccount
|
||||
name: secret-sync-sa
|
||||
namespace: certificates-ops
|
||||
name: tls-sync
|
||||
namespace: {{ .Release.Namespace }}
|
||||
|
||||
24
helm/tls-sync/ops/templates/secret-kubeconfig-template.yaml
Normal file
24
helm/tls-sync/ops/templates/secret-kubeconfig-template.yaml
Normal file
@@ -0,0 +1,24 @@
|
||||
# Template pour créer le Secret contenant les kubeconfigs
|
||||
# Ce fichier est un template - vous devez créer le Secret manuellement
|
||||
# avec vos kubeconfigs pour chaque cluster
|
||||
#
|
||||
# Exemple de commande pour créer le Secret :
|
||||
#
|
||||
# kubectl create secret generic tls-sync-kubeconfig \
|
||||
# --from-file=config=/root/.kube/config \
|
||||
# -n certificates-ops \
|
||||
# --dry-run=client -o yaml | kubectl apply -f -
|
||||
#
|
||||
# OU si vous avez plusieurs fichiers kubeconfig :
|
||||
#
|
||||
# kubectl create secret generic tls-sync-kubeconfig \
|
||||
# --from-file=cluster-dev=/path/to/dev-kubeconfig \
|
||||
# --from-file=cluster-rct=/path/to/rct-kubeconfig \
|
||||
# --from-file=cluster-prd=/path/to/prd-kubeconfig \
|
||||
# -n certificates-ops \
|
||||
# --dry-run=client -o yaml | kubectl apply -f -
|
||||
#
|
||||
# Note: Le CronJob monte ce Secret dans /root/.kube
|
||||
# Assurez-vous que le fichier principal s'appelle 'config' ou
|
||||
# configurez votre script pour utiliser les fichiers appropriés
|
||||
|
||||
36
helm/tls-sync/ops/values.yaml
Normal file
36
helm/tls-sync/ops/values.yaml
Normal file
@@ -0,0 +1,36 @@
|
||||
# Configuration pour la synchronisation automatique des secrets TLS
|
||||
tlsSync:
|
||||
# Intervalle de synchronisation (format cron)
|
||||
# Par défaut: toutes les heures
|
||||
schedule: "0 * * * *" # Toutes les heures à minute 0
|
||||
|
||||
# Namespace source où se trouvent les certificats
|
||||
sourceNamespace: "certificates-ops"
|
||||
|
||||
# Image à utiliser (doit contenir kubectl et bash)
|
||||
image:
|
||||
repository: bitnami/kubectl
|
||||
tag: "1.31"
|
||||
pullPolicy: IfNotPresent
|
||||
|
||||
# Ressources pour le Job
|
||||
resources:
|
||||
requests:
|
||||
memory: "64Mi"
|
||||
cpu: "50m"
|
||||
limits:
|
||||
memory: "128Mi"
|
||||
cpu: "200m"
|
||||
|
||||
# Nombre de jobs réussis à conserver
|
||||
successfulJobsHistoryLimit: 3
|
||||
|
||||
# Nombre de jobs échoués à conserver
|
||||
failedJobsHistoryLimit: 3
|
||||
|
||||
# Timeout pour le job (en secondes)
|
||||
jobTimeout: 300 # 5 minutes
|
||||
|
||||
# Concurrency policy: Allow, Forbid, Replace
|
||||
concurrencyPolicy: Forbid
|
||||
|
||||
Reference in New Issue
Block a user