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

```bash
# 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

```bash
# 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

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

```yaml
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 :

```yaml
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

```bash
# 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 :
```bash
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 :
```bash
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 :
```bash
# 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 :
```bash
kubectl get certificates -n certificates-ops --context=cluster-ops
```