253 lines
7.3 KiB
Markdown
253 lines
7.3 KiB
Markdown
# 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
|
|
```
|
|
|