# Reverse Proxy Traefik pour Équipements Externes

Ce guide explique comment utiliser Traefik comme reverse proxy pour exposer vos équipements externes (pfSense, OpenMediaVault, NAS, etc.) via les certificats TLS générés par cert-manager, **sans exporter les certificats**.

## Avantages de cette approche

✅ **Certificats gérés automatiquement** : Les certificats restent dans Kubernetes et sont renouvelés automatiquement par cert-manager  
✅ **Configuration centralisée** : Tous les certificats sont gérés au même endroit  
✅ **Pas d'export/import** : Plus besoin d'exporter et importer les certificats sur chaque équipement  
✅ **Sécurité** : Les certificats ne quittent jamais le cluster Kubernetes  
✅ **HTTPS automatique** : Traefik gère le TLS de bout en bout  

## Architecture

```
Internet/Intranet
    ↓
Traefik (Kubernetes) ← Certificat wildcard (*.dev.gkdomaine.fr)
    ↓ HTTPS
Équipement externe (pfSense, OMV, NAS, etc.) ← HTTP (interne)
```

## Prérequis

1. **Traefik déployé** dans le cluster avec accès aux certificats wildcard
2. **Certificats wildcard** générés (ex: `wildcard-prd-tls` pour la production)
3. **Accès réseau** depuis Traefik vers les équipements externes
4. **Service externe** accessible en HTTP (ou HTTPS avec certificat auto-signé)

⚠️ **Note** : Pour le moment, seuls les services externes en **production** sont configurés. Les environnements dev et rct peuvent être ajoutés ultérieurement si nécessaire.

## Configuration de base

### 1. Créer un IngressRoute pour un équipement externe

Créez un fichier `helm/traefik/dev/templates/external-pfsense.yaml` :

```yaml
---
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: pfsense-external
  namespace: traefik-dev
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`pfsense.dev.gkdomaine.fr`)
      kind: Rule
      services:
        - name: pfsense-backend
          port: 80
          scheme: http
          # Optionnel : si pfSense utilise HTTPS avec certificat auto-signé
          # scheme: https
          # serversTransport: pfsense-insecure
  tls:
    secretName: wildcard-dev-tls
```

### 2. Créer un Service Kubernetes pointant vers l'équipement externe

Créez un fichier `helm/traefik/dev/templates/external-services.yaml` :

```yaml
---
# Service pour pfSense
apiVersion: v1
kind: Service
metadata:
  name: pfsense-backend
  namespace: traefik-dev
spec:
  type: ExternalName
  externalName: 192.168.1.1  # IP interne de pfSense
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
---
# Service pour OpenMediaVault
apiVersion: v1
kind: Service
metadata:
  name: omv-backend
  namespace: traefik-dev
spec:
  type: ExternalName
  externalName: 192.168.1.10  # IP interne d'OpenMediaVault
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
---
# Service pour Synology NAS
apiVersion: v1
kind: Service
metadata:
  name: synology-backend
  namespace: traefik-dev
spec:
  type: ExternalName
  externalName: 192.168.1.20  # IP interne du NAS
  ports:
    - port: 5000  # Port DSM
      targetPort: 5000
      protocol: TCP
```

### 3. Configuration pour HTTPS backend (certificat auto-signé)

Si votre équipement utilise HTTPS avec un certificat auto-signé, créez un `ServersTransport` :

```yaml
---
apiVersion: traefik.io/v1alpha1
kind: ServersTransport
metadata:
  name: pfsense-insecure
  namespace: traefik-dev
spec:
  insecureSkipVerify: true  # Ignorer la vérification du certificat
```

## Exemples complets par équipement

### pfSense

```yaml
---
apiVersion: v1
kind: Service
metadata:
  name: pfsense-backend
  namespace: traefik-dev
spec:
  type: ExternalName
  externalName: 192.168.1.1  # IP de pfSense
  ports:
    - port: 80
      targetPort: 80
---
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: pfsense
  namespace: traefik-dev
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`pfsense.dev.gkdomaine.fr`)
      kind: Rule
      services:
        - name: pfsense-backend
          port: 80
  tls:
    secretName: wildcard-dev-tls
```

**Configuration pfSense** :
1. Allez dans **System > Advanced > Admin Access**
2. Désactivez **HTTPS Redirect** (Traefik gère le HTTPS)
3. Optionnel : Configurez **Trusted Proxies** avec l'IP de Traefik pour les headers X-Forwarded-*

### OpenMediaVault

```yaml
---
apiVersion: v1
kind: Service
metadata:
  name: omv-backend
  namespace: traefik-dev
spec:
  type: ExternalName
  externalName: 192.168.1.10  # IP d'OpenMediaVault
  ports:
    - port: 80
      targetPort: 80
---
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: omv
  namespace: traefik-dev
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`omv.dev.gkdomaine.fr`)
      kind: Rule
      services:
        - name: omv-backend
          port: 80
  tls:
    secretName: wildcard-dev-tls
```

**Configuration OpenMediaVault** :
1. Allez dans **System > Certificates > SSL**
2. Désactivez le certificat SSL (Traefik gère le HTTPS)
3. Configurez les **Trusted Proxies** dans **System > Network > General**

### Synology NAS

```yaml
---
apiVersion: v1
kind: Service
metadata:
  name: synology-backend
  namespace: traefik-dev
spec:
  type: ExternalName
  externalName: 192.168.1.20  # IP du NAS
  ports:
    - port: 5000  # Port DSM
      targetPort: 5000
---
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: synology
  namespace: traefik-dev
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`nas.dev.gkdomaine.fr`)
      kind: Rule
      services:
        - name: synology-backend
          port: 5000
  tls:
    secretName: wildcard-dev-tls
```

**Configuration Synology** :
1. Allez dans **Control Panel > Network > DSM Settings**
2. Désactivez **HTTPS** (Traefik gère le HTTPS)
3. Configurez **Reverse Proxy** si nécessaire

### Autres équipements

Le principe est le même pour tous les équipements :

1. **Créer un Service** de type `ExternalName` pointant vers l'IP de l'équipement
2. **Créer un IngressRoute** avec :
   - Le domaine souhaité (ex: `equipement.dev.gkdomaine.fr`)
   - Le service backend créé
   - Le certificat wildcard (`wildcard-dev-tls`)

## Configuration avancée

### Headers personnalisés

Pour passer des headers spécifiques à l'équipement backend :

```yaml
apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
  name: pfsense-headers
  namespace: traefik-dev
spec:
  headers:
    customRequestHeaders:
      X-Forwarded-Proto: "https"
      X-Real-IP: ""
---
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: pfsense
  namespace: traefik-dev
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`pfsense.dev.gkdomaine.fr`)
      kind: Rule
      services:
        - name: pfsense-backend
          port: 80
      middlewares:
        - name: pfsense-headers
  tls:
    secretName: wildcard-dev-tls
```

### Authentification basique

Pour ajouter une authentification HTTP Basic :

```yaml
apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
  name: pfsense-auth
  namespace: traefik-dev
spec:
  basicAuth:
    secret: pfsense-basic-auth  # Secret contenant user:password hashé
---
apiVersion: v1
kind: Secret
metadata:
  name: pfsense-basic-auth
  namespace: traefik-dev
type: Opaque
data:
  users: |  # Format: user:password_hash (généré avec htpasswd)
    admin:$apr1$...
```

### Redirection HTTP vers HTTPS

Pour rediriger automatiquement HTTP vers HTTPS :

```yaml
apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
  name: redirect-https
  namespace: traefik-dev
spec:
  redirectScheme:
    scheme: https
    permanent: true
---
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: pfsense-http-redirect
  namespace: traefik-dev
spec:
  entryPoints:
    - web
  routes:
    - match: Host(`pfsense.dev.gkdomaine.fr`)
      kind: Rule
      middlewares:
        - name: redirect-https
      services:
        - name: pfsense-backend
          port: 80
```

## Structure recommandée

Créez un chart Helm dédié pour les équipements externes :

```
helm/
  └── external-devices/
      └── dev/
          ├── Chart.yaml
          ├── values.yaml
          └── templates/
              ├── services.yaml
              ├── ingressroutes.yaml
              └── middlewares.yaml
```

**values.yaml** (production) :

```yaml
externalDevices:
  pfsense:
    enabled: true
    domain: "pfsense.prd.gkdomaine.fr"
    ip: "192.168.1.1"
    port: 80
    tlsSecret: "wildcard-prd-tls"
  
  omv:
    enabled: true
    domain: "omv.prd.gkdomaine.fr"
    ip: "192.168.1.10"
    port: 80
    tlsSecret: "wildcard-prd-tls"
  
  synology:
    enabled: true
    domain: "nas.prd.gkdomaine.fr"
    ip: "192.168.1.20"
    port: 5000
    tlsSecret: "wildcard-prd-tls"
```

## Vérification

### Vérifier que les services sont créés

```bash
kubectl get services -n traefik-dev | grep -E "pfsense|omv|synology"
```

### Vérifier que les IngressRoute sont créés

```bash
kubectl get ingressroute -n traefik-dev
```

### Tester l'accès

```bash
# Test depuis l'intérieur du cluster
curl -k https://pfsense.dev.gkdomaine.fr

# Vérifier les logs Traefik
kubectl logs -n traefik-dev -l app.kubernetes.io/name=traefik --tail=50
```

## Dépannage

### Erreur "no endpoints available"

Vérifiez que l'IP de l'équipement est correcte et accessible depuis les pods Traefik :

```bash
# Depuis un pod Traefik
kubectl exec -n traefik-dev -it <traefik-pod> -- curl http://192.168.1.1
```

### Erreur "certificate not found"

Vérifiez que le secret TLS existe :

```bash
kubectl get secret wildcard-prd-tls -n traefik-prd
```

### Équipement non accessible

Vérifiez :
1. **Réseau** : L'IP est-elle accessible depuis les pods Traefik ?
2. **Firewall** : Le port est-il ouvert sur l'équipement ?
3. **Service** : Le service Kubernetes pointe-t-il vers la bonne IP/port ?

## Sécurité

⚠️ **Important** :

1. **Restreindre l'accès** : Utilisez des NetworkPolicies pour limiter l'accès aux équipements
2. **Authentification** : Ajoutez une authentification (Basic Auth, OAuth, etc.) pour les équipements sensibles
3. **Whitelist IP** : Limitez l'accès aux IPs autorisées si possible
4. **Monitoring** : Surveillez les accès aux équipements via les logs Traefik

## Avantages vs Export de certificats

| Critère | Reverse Proxy | Export de certificats |
|---------|---------------|----------------------|
| Gestion des certificats | ✅ Automatique | ❌ Manuel |
| Renouvellement | ✅ Automatique | ❌ Manuel |
| Configuration | ✅ Centralisée | ❌ Par équipement |
| Sécurité | ✅ Certificats dans K8s | ⚠️ Certificats exportés |
| Complexité | ✅ Simple | ❌ Plus complexe |

## Conclusion

La solution reverse proxy avec Traefik est **recommandée** car elle :
- Simplifie la gestion des certificats
- Centralise la configuration
- Améliore la sécurité
- Réduit la maintenance

Les équipements externes n'ont plus besoin de gérer les certificats TLS - Traefik s'en charge complètement !