kubernetes/argocd
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
84b7bf8451c5514df029f10fa5dcc8d8476dc86d
argocd/docs/EXPORT-CERTIFICATS-EXTERNES.md
Melvin GABALI b6c6366c59 add external device
2026-01-22 23:34:56 +01:00

7.3 KiB
Raw Blame History

Export des Certificats TLS pour Équipements Externes

Ce guide explique comment exporter et utiliser les certificats TLS générés par cert-manager pour des équipements externes au cluster Kubernetes (pfSense, OpenMediaVault, NAS, etc.).

Vue d'ensemble

Les certificats TLS sont générés par cert-manager dans le namespace certificates-ops et stockés sous forme de secrets Kubernetes. Pour les utiliser sur des équipements externes, il faut :

  1. Exporter le certificat depuis Kubernetes
  2. Convertir au format approprié (PEM, PKCS12, etc.)
  3. Importer dans l'équipement externe
  4. Automatiser le renouvellement (optionnel)

Méthode 1 : Export manuel avec script

Prérequis

  • Accès au cluster Kubernetes avec kubectl
  • openssl installé sur votre machine
  • base64 disponible (généralement inclus)

Export du certificat

Utilisez le script scripts/export-certificate.sh :

# Export en format PEM (par défaut)
./scripts/export-certificate.sh wildcard-prd-tls certificates-ops cluster-ops ./certs pem

# Export en format PKCS12 (pour pfSense)
./scripts/export-certificate.sh wildcard-prd-tls certificates-ops cluster-ops ./certs pkcs12

Formats disponibles

  • PEM : Format standard, certificat et clé séparés (.crt et .key)
  • PKCS12/PFX : Format conteneurisé avec certificat et clé dans un seul fichier (.p12 ou .pfx)

Méthode 2 : Export direct avec kubectl

Export en format PEM

# Définir les variables
SECRET_NAME="wildcard-prd-tls"
NAMESPACE="certificates-ops"
CONTEXT="cluster-ops"
OUTPUT_DIR="./certs"

# Créer le répertoire
mkdir -p "$OUTPUT_DIR"

# Extraire le certificat
kubectl get secret "$SECRET_NAME" -n "$NAMESPACE" --context="$CONTEXT" \
  -o jsonpath='{.data.tls\.crt}' | base64 -d > "$OUTPUT_DIR/certificate.crt"

# Extraire la clé privée
kubectl get secret "$SECRET_NAME" -n "$NAMESPACE" --context="$CONTEXT" \
  -o jsonpath='{.data.tls\.key}' | base64 -d > "$OUTPUT_DIR/private.key"

Conversion en PKCS12

# Créer un fichier PKCS12 (mot de passe optionnel)
openssl pkcs12 -export \
  -out "$OUTPUT_DIR/certificate.p12" \
  -inkey "$OUTPUT_DIR/private.key" \
  -in "$OUTPUT_DIR/certificate.crt" \
  -name "wildcard-prd" \
  -passout pass:  # Laissez vide pour aucun mot de passe

Import dans les équipements

pfSense

Méthode 1 : Import PKCS12 (recommandé)

  1. Allez dans System > Certificates
  2. Cliquez sur Import
  3. Sélectionnez le fichier .p12 ou .pfx
  4. Entrez le mot de passe si nécessaire
  5. Cliquez sur Import

Méthode 2 : Import PEM séparé

  1. Allez dans System > Certificates
  2. Cliquez sur Add
  3. Dans Method, sélectionnez Import an existing Certificate
  4. Collez le contenu du fichier .crt dans Certificate data
  5. Collez le contenu du fichier .key dans Private key data
  6. Cliquez sur Save

Utilisation dans pfSense

  1. Allez dans System > Certificates
  2. Sélectionnez le certificat importé
  3. Utilisez-le dans :
    • System > Advanced > WebGUI (certificat HTTPS)
    • Services > HAProxy (certificats backend)
    • VPN > OpenVPN (certificats serveur)

OpenMediaVault

  1. Allez dans System > Certificates > SSL
  2. Cliquez sur Import
  3. Sélectionnez le fichier certificat (.crt ou .p12)
  4. Si vous utilisez PEM, importez séparément :
    • Certificate : Fichier .crt
    • Private Key : Fichier .key
  5. Cliquez sur Save

Synology NAS

  1. Allez dans Control Panel > Security > Certificate
  2. Cliquez sur Add
  3. Sélectionnez Import Certificate
  4. Choisissez le fichier (.p12 ou .crt + .key)
  5. Entrez le mot de passe si nécessaire
  6. Cliquez sur OK

Autres équipements

La plupart des équipements réseau supportent l'import de certificats en format :

  • PEM : Certificat et clé séparés
  • PKCS12/PFX : Format conteneurisé

Consultez la documentation de votre équipement pour les détails spécifiques.

Automatisation du renouvellement

Les certificats Let's Encrypt sont valides 90 jours et sont renouvelés automatiquement par cert-manager. Pour synchroniser automatiquement les certificats vers vos équipements externes :

Option 1 : Webhook cert-manager

Créez un webhook qui s'exécute lors du renouvellement du certificat :

apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: wildcard-prd-tls
  namespace: certificates-ops
spec:
  # ... configuration du certificat ...
  secretTemplate:
    annotations:
      cert-manager.io/allow-direct-injection: "true"
  # Webhook pour exporter automatiquement
  # (nécessite un contrôleur personnalisé)

Option 2 : Script CronJob

Créez un CronJob qui vérifie périodiquement les certificats et les exporte :

apiVersion: batch/v1
kind: CronJob
metadata:
  name: export-certificates
  namespace: certificates-ops
spec:
  schedule: "0 0 * * *"  # Tous les jours
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: export
            image: alpine/k8s:1.33.0
            command:
            - /bin/sh
            - -c
            - |
              # Exporter le certificat
              kubectl get secret wildcard-prd-tls -n certificates-ops \
                -o jsonpath='{.data.tls\.crt}' | base64 -d > /export/cert.crt
              # Envoyer vers l'équipement externe (API, SCP, etc.)
              # Exemple avec curl vers une API pfSense
              # curl -X POST https://pfsense.example.com/api/certificates \
              #   -F "cert=@/export/cert.crt"

Option 3 : API REST

Si votre équipement supporte une API REST (comme pfSense), créez un service qui :

  1. Surveille les changements de secrets Kubernetes
  2. Exporte automatiquement le certificat
  3. Envoie une requête API à l'équipement pour mettre à jour le certificat

Sécurité

⚠️ Important : Les certificats et clés privées sont des données sensibles.

  • Ne stockez jamais les clés privées dans Git
  • Supprimez les fichiers exportés après import
  • Utilisez des permissions restrictives sur les fichiers (chmod 600)
  • Chiffrez les fichiers si vous devez les transférer
# Permissions restrictives
chmod 600 certificate.key
chmod 644 certificate.crt

# Supprimer après import
rm -f certificate.*

Dépannage

Erreur "secret not found"

Vérifiez que le secret existe :

kubectl get secret wildcard-prd-tls -n certificates-ops --context=cluster-ops

Erreur "certificate expired"

Les certificats sont renouvelés automatiquement. Vérifiez le statut :

kubectl get certificate wildcard-prd-tls -n certificates-ops --context=cluster-ops

Format non reconnu par l'équipement

Essayez de convertir dans un autre format :

# PEM vers DER
openssl x509 -in certificate.crt -out certificate.der -outform DER

# PKCS12 avec mot de passe
openssl pkcs12 -export -out certificate.p12 \
  -inkey private.key -in certificate.crt \
  -passout pass:VOTRE_MOT_DE_PASSE

Exemples de certificats disponibles

Dans le namespace certificates-ops :

  • wildcard-dev-tls : *.dev.gkdomaine.fr
  • wildcard-rct-tls : *.rct.gkdomaine.fr
  • wildcard-prd-tls : *.prd.gkdomaine.fr

Pour lister tous les certificats :

kubectl get certificates -n certificates-ops --context=cluster-ops