> ## Documentation Index
> Fetch the complete documentation index at: https://ai-kb.automationanywhere.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Infrastructure Terraform EKB

> Infrastructure-as-code Terraform et Terragrunt pour gérer la plateforme EKB sur AWS EKS, avec stubs de support pour GKE, AKS et Kubernetes bare-metal.

Cet article contient l'infrastructure-as-code Terraform et Terragrunt pour gérer la plateforme EKB sur AWS EKS, avec stubs de support pour GKE, AKS et Kubernetes bare-metal. Il inclut tous les déploiements de graphiques Helm et les modèles de configuration d'environnement.

***

## Documentation

| Document                                                                                                        | Description                                                                              |
| --------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| [Guide de déploiement Terragrunt](/offerings/on-premise/kubernetes-deployment/terragrunt-deployment)            | Guide étape par étape pour créer et déployer un nouvel environnement                     |
| [Présentation de l'architecture AWS](/offerings/on-premise/kubernetes-deployment/aws-architecture)              | Présentation de l'architecture, descriptions des composants et flux de données           |
| [Stratégie de récupération après sinistre](/offerings/on-premise/kubernetes-deployment/disaster-recovery-guide) | Stratégie de DR, objectifs RTO/RPO, systèmes de sauvegarde et procédures de récupération |
| [Liste de contrôle des prérequis](/offerings/on-premise/kubernetes-deployment/eks-deployment-prerequisites)     | Liste de contrôle avant déploiement à compléter avec le client                           |

***

## Structure du référentiel

```
ekb-terraform/
├── root.hcl                              # Configuration Terragrunt racine (état distant, génération de fournisseur)
│
├── modules/                              # Modules Terraform réutilisables
│   ├── eks/                              # Cluster EKS AWS, VPC, Karpenter, IAM, versions Helm
│   ├── aws-services/                     # ElastiCache Redis, Amazon MQ RabbitMQ
│   ├── helm/                             # Module de version Helm générique
│   ├── state/                            # Bootstrap du bucket d'état S3
│   ├── aks/                              # Azure AKS (stub)
│   ├── gke/                              # Google GKE (stub)
│   └── baremetal/                        # Kubernetes bare-metal (stub)
│
├── terragrunt/
│   ├── .gitignore
│   └── environments/
│       ├── STATE_MANAGEMENT_README.md
│       └── env-template-folder/          # Modèle pour les nouveaux environnements — copier et remplir les espaces réservés
│           ├── terragrunt.hcl            # Configuration d'environnement principal (cluster, versions Helm, services AWS)
│           ├── state/
│           │   └── terragrunt.hcl        # Bootstrap du bucket d'état pour cet environnement
│           └── values/                   # Valeurs Helm par graphique (un fichier par graphique)
│               ├── infrastructure.yaml       # Contrôleur AWS Load Balancer
│               ├── aws-ebs-csi-driver.yaml   # Pilote CSI EBS
│               ├── karpenter.yaml            # NodePool Karpenter
│               ├── karpenter-nodeclasses.yaml# Définitions EC2NodeClass
│               ├── karpenter-values.yaml     # Valeurs du contrôleur Karpenter
│               ├── keda.yaml                 # Autoscaler KEDA
│               ├── odin-services.yaml        # Services d'application EKB
│               ├── cloudnative-pg.yaml       # Opérateur CloudNativePG (ENABLE_CNPG)
│               ├── ha-supabase-db.yaml       # Cluster Postgres HA via CNPG (ENABLE_HA_SUPABASE_DB)
│               ├── supabase.yaml             # Pile application Supabase (ENABLE_SUPABASE)
│               ├── signoz.yaml               # Plateforme d'observabilité SigNoz (ENABLE_SIGNOZ)
│               └── signoz-k8s-infra.yaml     # Agent de métriques k8s SigNoz (ENABLE_SIGNOZ)
│
└── helm-deployment/                      # Graphiques Helm vendorisés / locaux
    ├── infrastructure/                   # Graphique d'enveloppe du contrôleur ALB
    ├── odin-services/odin-services/      # Plateforme EKB (Web, API, Celery, Automator, Ingress)
    ├── cloudnative-pg/                   # Graphique de l'opérateur CloudNativePG
    ├── ha-supabase-db/                   # BD Supabase HA (Cluster CNPG + PgBouncer + sauvegardes barman)
    ├── supabase-kubernetes-ha/           # Pile application Supabase complète
    ├── signoz/                           # Plateforme d'observabilité SigNoz
    └── k8s-infra/                        # Agent de métriques de cluster k8s SigNoz
```

***

## Démarrage rapide

### 1. Installer les outils requis

**Terraform**

```bash theme={null}
# macOS
brew install terraform
 
# Linux
sudo apt update && sudo apt install terraform
```

**Terragrunt**

```bash theme={null}
# macOS
brew install terragrunt
 
# Linux / macOS (manuel)
curl -Lo /usr/local/bin/terragrunt \
  https://github.com/gruntwork-io/terragrunt/releases/latest/download/terragrunt_linux_amd64
chmod +x /usr/local/bin/terragrunt
```

**kubectl et Helm**

```bash theme={null}
# macOS
brew install kubectl helm
 
# Linux
curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -m 0755 kubectl /usr/local/bin/kubectl
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
```

**Vérifier l'installation**

```bash theme={null}
terraform --version
terragrunt --version
kubectl version --client
helm version
aws sts get-caller-identity
```

***

### 2. Créer un nouvel environnement

Les nouveaux environnements sont créés en copiant `env-template-folder` et en remplissant les espaces réservés.

Consultez [Guide de déploiement Terragrunt](/offerings/on-premise/kubernetes-deployment/terragrunt-deployment) pour le processus complet étape par étape. Le flux de haut niveau est :

```bash theme={null}
# 1. Copier le modèle
cp -r terragrunt/environments/env-template-folder terragrunt/environments/your-env-name
 
# 2. Remplir tous les espaces réservés <YOUR_*> dans :
#    - terragrunt/environments/your-env-name/terragrunt.hcl
#    - terragrunt/environments/your-env-name/state/terragrunt.hcl
#    - terragrunt/environments/your-env-name/values/*.yaml
 
# 3. Bootstrap du bucket d'état
cd terragrunt/environments/your-env-name/state
terragrunt apply
 
# 4. Définir les variables d'environnement et déployer
cd ../
export ENABLE_ALB_CONTROLLER=true
export WEB_DOMAIN="app.example.com"
export WEB_CERTIFICATE_ARN="arn:aws:acm:<region>:<account>:certificate/<id>"
# ... (voir TERRAGRUNT_DEPLOYMENT_GUIDE.md pour la liste complète des variables)
 
terragrunt apply
```

***

## Drapeaux d'activation/désactivation de service

Tous les services optionnels sont activés via des variables d'environnement. Définissez-les avant d'exécuter `terragrunt apply`.

| Variable                | Défaut  | Service                                                         |
| ----------------------- | ------- | --------------------------------------------------------------- |
| `ENABLE_ALB_CONTROLLER` | `true`  | Contrôleur AWS Load Balancer                                    |
| `ENABLE_AWS_SERVICES`   | `false` | ElastiCache Redis + Amazon MQ RabbitMQ                          |
| `ENABLE_CNPG`           | `false` | Opérateur CloudNativePG                                         |
| `ENABLE_HA_SUPABASE_DB` | `false` | Cluster PostgreSQL HA (nécessite `ENABLE_CNPG=true`)            |
| `ENABLE_SUPABASE`       | `false` | Pile Supabase complète (nécessite `ENABLE_HA_SUPABASE_DB=true`) |
| `ENABLE_SIGNOZ`         | `false` | SigNoz observabilité + agent k8s-infra                          |

<Info>
  **Ordre de déploiement de Supabase auto-hébergé**

  Les composants Supabase doivent être déployés dans l'ordre :

  ```bash theme={null}
  ENABLE_CNPG=true           terragrunt apply --target='helm_release.local[\"cloudnative-pg\"]'
  ENABLE_HA_SUPABASE_DB=true terragrunt apply --target='helm_release.local[\"ha-supabase-db\"]'
  ENABLE_SUPABASE=true       terragrunt apply --target='helm_release.local[\"supabase\"]'
  ```
</Info>

***

## Référence des graphiques Helm

| Graphique (dans `helm-deployment/`) | Espace de noms   | Activé par              | Description                                  |
| ----------------------------------- | ---------------- | ----------------------- | -------------------------------------------- |
| `infrastructure`                    | `infrastructure` | Toujours                | Contrôleur AWS Load Balancer                 |
| `odin-services/odin-services`       | `default`        | Toujours                | Web, FastAPI, Celery, Automator, Ingress     |
| `aws-ebs-csi-driver` (upstream)     | `kube-system`    | Toujours                | Pilote de volume persistant EBS              |
| `keda` (upstream)                   | `keda`           | Toujours                | Autoscaling de pods                          |
| `cloudnative-pg`                    | `cnpg-system`    | `ENABLE_CNPG`           | Opérateur PostgreSQL                         |
| `ha-supabase-db`                    | `ha-supabase-db` | `ENABLE_HA_SUPABASE_DB` | Postgres HA + PgBouncer + sauvegardes barman |
| `supabase-kubernetes-ha`            | `supabase`       | `ENABLE_SUPABASE`       | Kong, Auth, Storage, Studio, Realtime        |
| `signoz`                            | `monitoring`     | `ENABLE_SIGNOZ`         | Traçage distribué, métriques, journaux       |
| `k8s-infra` (upstream)              | `monitoring`     | `ENABLE_SIGNOZ`         | Agent DaemonSet de métriques de cluster      |

***

## Référence des modules

### `modules/eks`

Le module principal. Provisionne :

* VPC avec subnets publics/privés sur 3 AZs
* Cluster EKS (Kubernetes 1.33) et groupe de nœuds gérés pour Karpenter
* Contrôleur Karpenter + NodePool + EC2NodeClass
* Rôles IAM (cluster, groupe de nœuds, Karpenter, contrôleur ALB, pilote CSI EBS)
* Toutes les versions Helm via la carte d'entrée `helm_releases`

### `modules/aws-services`

Provisionne ElastiCache Redis et Amazon MQ RabbitMQ. Actif uniquement lorsque `ENABLE_AWS_SERVICES=true`.

### `modules/state`

Bootstrap du bucket S3 d'état pour un nouvel environnement (versioning, chiffrement, blocage d'accès public).

### `modules/helm`

Module de version Helm réutilisable supportant les référentiels de graphiques upstream et les graphiques locaux `chart_path`.

***

## Configuration d'environnement

### Espaces réservés

Chaque valeur dans `env-template-folder` spécifique à l'environnement utilise un espace réservé `<YOUR_*>`. Exécutez ce qui suit pour vérifier qu'aucun n'a été oublié avant de déployer :

```bash theme={null}
grep -r "<YOUR_" terragrunt/environments/your-env-name/
```

### État distant

L'état est stocké dans S3 par environnement. Le bucket est amorcé par `state/terragrunt.hcl` et référencé par `root.hcl`. Le modèle d'appellation est `ekb-terraform-state-<env-name>`.

### Secrets

<Warning>
  Les valeurs sensibles (mots de passe, clés API, ARNs de certificats) ne sont **jamais validées**. Elles sont transmises en tant que variables d'environnement consommées par les appels `get_env()` dans `terragrunt.hcl`, ou en tant qu'espaces réservés `<YOUR_*>` dans les fichiers de valeurs qui doivent être remplis avant le déploiement.
</Warning>

***

## Dépannage

**Vérifier les identifiants AWS**

```bash theme={null}
aws sts get-caller-identity
```

**Vérifier l'accès au cluster**

```bash theme={null}
aws eks update-kubeconfig --region <region> --name <cluster-name>
kubectl get nodes
kubectl get pods -A
```

**Vérifier le contrôleur ALB**

```bash theme={null}
kubectl get pods -n infrastructure | grep aws-load-balancer-controller
kubectl get ingress -A
```

**Vérifier Karpenter**

```bash theme={null}
kubectl get pods -n kube-system | grep karpenter
kubectl get nodepools
kubectl get nodeclaims
```

**Vérifier le verrouillage d'état**

```bash theme={null}
# Forcer le déverrouillage d'un état bloqué (utiliser l'ID de verrouillage du message d'erreur)
cd terragrunt/environments/your-env-name
terragrunt force-unlock <lock-id>
```

**Vérifier l'absence d'espaces réservés restants**

```bash theme={null}
grep -r "<YOUR_" terragrunt/environments/your-env-name/
```

**Vérifier l'état de la version Helm**

```bash theme={null}
helm list -A
helm status <release-name> -n <namespace>
helm get values <release-name> -n <namespace>
```

***

## Support multi-cloud (Planifié)

| Plateforme | Statut | Module              |
| ---------- | ------ | ------------------- |
| AWS EKS    | Actif  | `modules/eks`       |
| Azure AKS  | Stub   | `modules/aks`       |
| Google GKE | Stub   | `modules/gke`       |
| Bare metal | Stub   | `modules/baremetal` |