update

apps/applicationset-external-devices.yaml

@@ -26,6 +26,9 @@ spec:
   template:
     metadata:
       name: external-devices-{{path.basename}}
+      annotations:
+        # Forcer ArgoCD à gérer les Endpoints
+        argocd.argoproj.io/sync-options: "ServerSideApply=true"
     spec:
       project: '{{path.basename}}'
       source:
@@ -44,4 +47,6 @@ spec:
           selfHeal: true
         syncOptions:
           - CreateNamespace=true
+          # ServerSideApply pour mieux gérer les Endpoints
+          - ServerSideApply=true
 

apps/appproject-dev-endpoints.yaml

@@ -0,0 +1,28 @@
+# AppProject pour inclure les Endpoints dans ArgoCD
+# ⚠️ Ce fichier doit être appliqué manuellement ou via un autre mécanisme
+# car les AppProjects ne sont pas gérés par ApplicationSet
+#
+# Usage:
+#   kubectl apply -f apps/appproject-dev-endpoints.yaml
+#
+# Ou modifiez le projet existant :
+#   kubectl patch appproject dev -n argocd-ops --type merge -p "$(cat apps/appproject-dev-endpoints.yaml)"
+
+apiVersion: argoproj.io/v1alpha1
+kind: AppProject
+metadata:
+  name: dev
+  namespace: argocd-ops
+spec:
+  # Inclure les Endpoints dans les ressources autorisées
+  namespaceResourceWhitelist:
+    - group: ""
+      kind: Endpoints
+  # Autoriser tous les namespaces (ou spécifiez traefik-dev)
+  sourceNamespaces:
+    - '*'
+  # Autoriser tous les clusters (ou spécifiez cluster-dev)
+  destinations:
+    - namespace: '*'
+      server: '*'
+

docs/ARGO-CD-ENDPOINTS.md

@@ -0,0 +1,101 @@
+# Configuration ArgoCD pour gérer les Endpoints
+
+Par défaut, ArgoCD **exclut** les ressources de type `Endpoints` car elles sont généralement gérées automatiquement par Kubernetes. Pour que ArgoCD gère les Endpoints créés par Helm, il faut les inclure explicitement.
+
+## Solution 1 : Configurer le projet ArgoCD (Recommandé - OBLIGATOIRE)
+
+⚠️ **IMPORTANT** : Cette étape est **obligatoire**. Sans cette configuration, ArgoCD ne créera jamais les Endpoints, même avec les annotations dans les templates.
+
+Modifiez le projet ArgoCD pour inclure les Endpoints :
+
+```bash
+# Récupérer la configuration du projet
+kubectl get appproject dev -n argocd-ops -o yaml > project-dev.yaml
+
+# Ajouter resourceInclusions dans le projet
+```
+
+Ou via l'interface ArgoCD :
+1. Allez dans **Settings > Projects**
+2. Sélectionnez le projet `dev`
+3. Dans **Resource Inclusion**, ajoutez :
+   - **Group** : (vide)
+   - **Kind** : `Endpoints`
+4. Sauvegardez
+
+## Solution 2 : Configurer l'application directement
+
+Modifiez l'application `external-devices-dev` pour inclure les Endpoints :
+
+```bash
+kubectl patch application external-devices-dev -n argocd-ops \
+  --type merge \
+  -p '{"spec":{"source":{"helm":{"includeCRDs":true}}}}'
+```
+
+Puis ajoutez la configuration dans l'Application :
+
+```yaml
+apiVersion: argoproj.io/v1alpha1
+kind: Application
+metadata:
+  name: external-devices-dev
+  namespace: argocd-ops
+spec:
+  # ... autres configurations ...
+  source:
+    helm:
+      # Inclure les Endpoints
+      includeCRDs: true
+  # Ou utiliser resourceInclusions au niveau de l'application
+  # (nécessite ArgoCD 2.4+)
+```
+
+## Solution 3 : Modifier la configuration globale d'ArgoCD
+
+Modifiez le ConfigMap `argocd-cm` pour inclure les Endpoints globalement :
+
+```bash
+kubectl edit configmap argocd-cm -n argocd-ops
+```
+
+Ajoutez :
+
+```yaml
+resourceInclusions: |
+  - apiGroups: [""]
+    kinds: ["Endpoints"]
+    clusters: ["*"]
+```
+
+⚠️ **Attention** : Cette modification affecte **toutes** les applications ArgoCD.
+
+## Solution 4 : Utiliser une annotation sur l'Application
+
+Si vous utilisez ArgoCD 2.4+, vous pouvez ajouter une annotation directement sur l'Application :
+
+```yaml
+metadata:
+  annotations:
+    argocd.argoproj.io/sync-options: IncludeEndpoints=true
+```
+
+## Vérification
+
+Après la configuration, vérifiez que les Endpoints sont gérés :
+
+```bash
+# Vérifier que l'application voit les Endpoints
+argocd app get external-devices-dev
+
+# Vérifier que les Endpoints sont créés
+kubectl get endpoints omv-backend -n traefik-dev
+```
+
+## Recommandation
+
+Pour ce cas d'usage spécifique (Endpoints pour équipements externes), la **Solution 1** (configurer le projet) est recommandée car :
+- Elle est limitée au projet `dev`
+- Elle n'affecte pas les autres applications
+- Elle est persistante et versionnée si vous utilisez GitOps pour les projets
+

helm/external-devices/dev/templates/services.yaml

@@ -34,6 +34,8 @@ metadata:
     app.kubernetes.io/instance: {{ $.Release.Name }}
   annotations:
     argocd.argoproj.io/sync-wave: "0"
+    # Forcer ArgoCD à gérer cette ressource même si elle est normalement exclue
+    argocd.argoproj.io/sync-options: "ServerSideApply=true"
 subsets:
   - addresses:
       - ip: {{ $device.ip }}

scripts/create-endpoints-manually.sh

@@ -1,65 +0,0 @@
-#!/bin/bash
-# Script pour créer manuellement les Endpoints pour les équipements externes
-
-set -e
-
-NAMESPACE="${1:-traefik-dev}"
-SERVICE_NAME="${2:-omv-backend}"
-IP="${3:-10.78.20.107}"
-PORT="${4:-80}"
-
-if [ -z "$SERVICE_NAME" ] || [ -z "$IP" ]; then
-    echo "Usage: $0 [namespace] <service-name> <ip> [port]"
-    echo ""
-    echo "Exemple:"
-    echo "  $0 traefik-dev omv-backend 10.78.20.107 80"
-    exit 1
-fi
-
-echo "=== Création des Endpoints ==="
-echo "Namespace: $NAMESPACE"
-echo "Service: $SERVICE_NAME"
-echo "IP: $IP"
-echo "Port: $PORT"
-echo ""
-
-# Vérifier que le service existe
-if ! kubectl get service "$SERVICE_NAME" -n "$NAMESPACE" &>/dev/null; then
-    echo "❌ Erreur: Le service '$SERVICE_NAME' n'existe pas dans '$NAMESPACE'"
-    exit 1
-fi
-
-# Vérifier si les Endpoints existent déjà
-if kubectl get endpoints "$SERVICE_NAME" -n "$NAMESPACE" &>/dev/null; then
-    echo "⚠️  Les Endpoints existent déjà. Voulez-vous les mettre à jour ? (o/N)"
-    read -r REPLY
-    if [[ ! $REPLY =~ ^[OoYy]$ ]]; then
-        echo "Opération annulée"
-        exit 0
-    fi
-    echo "Suppression des anciens Endpoints..."
-    kubectl delete endpoints "$SERVICE_NAME" -n "$NAMESPACE"
-fi
-
-# Créer les Endpoints
-echo "Création des Endpoints..."
-kubectl create -f - <<EOF
-apiVersion: v1
-kind: Endpoints
-metadata:
-  name: $SERVICE_NAME
-  namespace: $NAMESPACE
-subsets:
-  - addresses:
-      - ip: $IP
-    ports:
-      - port: $PORT
-        protocol: TCP
-EOF
-
-echo ""
-echo "✅ Endpoints créés avec succès !"
-echo ""
-echo "Vérification:"
-kubectl get endpoints "$SERVICE_NAME" -n "$NAMESPACE" -o yaml
-

scripts/export-certificate.sh

@@ -1,127 +0,0 @@
-#!/bin/bash
-# Script pour exporter un certificat TLS depuis Kubernetes vers un format utilisable par des équipements externes
-
-set -e
-
-SECRET_NAME="${1}"
-NAMESPACE="${2:-certificates-ops}"
-CONTEXT="${3:-cluster-ops}"
-OUTPUT_DIR="${4:-./certificates-export}"
-FORMAT="${5:-pem}"  # pem, pkcs12, pfx
-
-if [ -z "$SECRET_NAME" ]; then
-    echo "Usage: $0 <secret-name> [namespace] [context] [output-dir] [format]"
-    echo ""
-    echo "Exemples:"
-    echo "  $0 wildcard-prd-tls certificates-ops cluster-ops ./certs pem"
-    echo "  $0 wildcard-prd-tls certificates-ops cluster-ops ./certs pkcs12"
-    echo ""
-    echo "Formats disponibles:"
-    echo "  - pem: Certificat et clé en format PEM (par défaut)"
-    echo "  - pkcs12: Format PKCS12 (.p12) pour pfSense, etc."
-    echo "  - pfx: Format PFX (identique à PKCS12)"
-    exit 1
-fi
-
-echo "=== Export du certificat TLS ==="
-echo "Secret: $SECRET_NAME"
-echo "Namespace: $NAMESPACE"
-echo "Context: $CONTEXT"
-echo "Format: $FORMAT"
-echo ""
-
-# Créer le répertoire de sortie
-mkdir -p "$OUTPUT_DIR"
-
-# Vérifier que le secret existe
-if ! kubectl get secret "$SECRET_NAME" -n "$NAMESPACE" --context="$CONTEXT" &>/dev/null; then
-    echo "❌ Erreur: Le secret '$SECRET_NAME' n'existe pas dans '$NAMESPACE'"
-    exit 1
-fi
-
-# Extraire le certificat et la clé
-echo "📥 Extraction du certificat depuis Kubernetes..."
-kubectl get secret "$SECRET_NAME" -n "$NAMESPACE" --context="$CONTEXT" -o jsonpath='{.data.tls\.crt}' | base64 -d > "$OUTPUT_DIR/$SECRET_NAME.crt"
-kubectl get secret "$SECRET_NAME" -n "$NAMESPACE" --context="$CONTEXT" -o jsonpath='{.data.tls\.key}' | base64 -d > "$OUTPUT_DIR/$SECRET_NAME.key"
-
-# Extraire la chaîne de certificats complète (certificat + CA)
-kubectl get secret "$SECRET_NAME" -n "$NAMESPACE" --context="$CONTEXT" -o jsonpath='{.data.ca\.crt}' | base64 -d > "$OUTPUT_DIR/$SECRET_NAME-ca.crt" 2>/dev/null || true
-
-echo "✅ Certificat et clé extraits"
-echo ""
-
-# Convertir selon le format demandé
-case "$FORMAT" in
-    pem)
-        echo "📄 Format PEM (déjà généré)"
-        echo "   Certificat: $OUTPUT_DIR/$SECRET_NAME.crt"
-        echo "   Clé privée: $OUTPUT_DIR/$SECRET_NAME.key"
-        if [ -f "$OUTPUT_DIR/$SECRET_NAME-ca.crt" ]; then
-            echo "   CA: $OUTPUT_DIR/$SECRET_NAME-ca.crt"
-        fi
-        ;;
-    pkcs12|pfx)
-        echo "📦 Conversion en format PKCS12..."
-        
-        # Demander un mot de passe pour le fichier PKCS12
-        read -sp "Mot de passe pour le fichier PKCS12 (laissez vide pour aucun): " PASSWORD
-        echo ""
-        
-        # Créer le fichier PKCS12
-        if [ -z "$PASSWORD" ]; then
-            openssl pkcs12 -export \
-                -out "$OUTPUT_DIR/$SECRET_NAME.p12" \
-                -inkey "$OUTPUT_DIR/$SECRET_NAME.key" \
-                -in "$OUTPUT_DIR/$SECRET_NAME.crt" \
-                -name "$SECRET_NAME" \
-                -passout pass:
-        else
-            openssl pkcs12 -export \
-                -out "$OUTPUT_DIR/$SECRET_NAME.p12" \
-                -inkey "$OUTPUT_DIR/$SECRET_NAME.key" \
-                -in "$OUTPUT_DIR/$SECRET_NAME.crt" \
-                -name "$SECRET_NAME" \
-                -passout pass:"$PASSWORD"
-        fi
-        
-        echo "✅ Fichier PKCS12 créé: $OUTPUT_DIR/$SECRET_NAME.p12"
-        ;;
-    *)
-        echo "❌ Format '$FORMAT' non supporté"
-        echo "   Formats disponibles: pem, pkcs12, pfx"
-        exit 1
-        ;;
-esac
-
-# Afficher les informations du certificat
-echo ""
-echo "📋 Informations du certificat:"
-openssl x509 -in "$OUTPUT_DIR/$SECRET_NAME.crt" -noout -subject -issuer -dates 2>/dev/null || echo "   (openssl non disponible pour afficher les détails)"
-
-echo ""
-echo "✅ Export terminé dans: $OUTPUT_DIR"
-echo ""
-echo "📝 Prochaines étapes:"
-echo ""
-case "$FORMAT" in
-    pem)
-        echo "Pour pfSense:"
-        echo "  1. Allez dans System > Certificates"
-        echo "  2. Cliquez sur 'Import'"
-        echo "  3. Importez le certificat ($SECRET_NAME.crt)"
-        echo "  4. Importez la clé privée ($SECRET_NAME.key)"
-        echo ""
-        echo "Pour OpenMediaVault:"
-        echo "  1. Allez dans System > Certificates > SSL"
-        echo "  2. Cliquez sur 'Import'"
-        echo "  3. Sélectionnez le certificat et la clé"
-        ;;
-    pkcs12|pfx)
-        echo "Pour pfSense:"
-        echo "  1. Allez dans System > Certificates"
-        echo "  2. Cliquez sur 'Import'"
-        echo "  3. Sélectionnez le fichier PKCS12 ($SECRET_NAME.p12)"
-        echo "  4. Entrez le mot de passe si vous en avez défini un"
-        ;;
-esac
-