# 02 — Prérequis

Tout ce dont vous avez besoin avant de commencer le déploiement.

---

## Comptes à créer

### Obligatoires

| Service | URL | Usage | Coût |
|---|---|---|---|
| **Hetzner Cloud** | https://console.hetzner.cloud | Serveurs, LB, Object Storage | Pay-as-you-go |
| **GitHub** | https://github.com | Code + GitHub Actions + GHCR (images Docker) | Gratuit |
| **Cloudflare** | https://cloudflare.com | DNS + WAF + CDN | Gratuit (plan Free) |
| **Neon.tech** | https://neon.tech | PostgreSQL managé | Free → $19/mois Pro |

### Recommandés (peuvent être substitués)

| Service | URL | Usage | Coût |
|---|---|---|---|
| **Upstash** | https://upstash.com | Redis serverless | Free → $10/mois |
| **Brevo** | https://brevo.com | Email SMTP (remplace SendGrid) | Gratuit jusqu'à 300/j |
| **Sentry** | https://sentry.io | Error tracking | Gratuit (5K events/mois) |

---

## Outils locaux à installer

### Outils essentiels

```bash
# macOS (avec Homebrew)
brew install kubectl helm hcloud vitobotta/tap/hetzner-k3s

# Vérification versions minimales requises
kubectl version --client    # >= 1.28
helm version                # >= 3.12
hcloud version              # >= 1.40
hetzner-k3s version         # >= 3.0
```

```bash
# Ubuntu/Debian
# kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl && sudo mv kubectl /usr/local/bin/

# helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# hcloud CLI
curl -Lo hcloud.tar.gz https://github.com/hetznercloud/cli/releases/latest/download/hcloud-linux-amd64.tar.gz
tar -xzf hcloud.tar.gz && sudo mv hcloud /usr/local/bin/

# hetzner-k3s
curl -Lo hetzner-k3s https://github.com/vitobotta/hetzner-k3s/releases/latest/download/hetzner-k3s-linux-amd64
chmod +x hetzner-k3s && sudo mv hetzner-k3s /usr/local/bin/
```

### Outils optionnels mais recommandés

```bash
# kubectx + kubens — changer de contexte/namespace facilement
brew install kubectx

# k9s — interface terminal pour Kubernetes (très utile)
brew install k9s

# stern — logs multi-pods en temps réel
brew install stern

# AWS CLI v2 — pour interagir avec Hetzner Object Storage
brew install awscli

# Docker — pour build et test des images en local
brew install --cask docker
```

---

## Clés SSH

Générez une paire de clés SSH dédiée pour Hetzner (ne réutilisez pas votre clé perso) :

```bash
# Générer une clé ED25519 (plus sécurisée et performante que RSA)
ssh-keygen -t ed25519 -C "xpeditis-hetzner-deploy" -f ~/.ssh/xpeditis_hetzner

# Résultat :
# ~/.ssh/xpeditis_hetzner      (clé privée — ne JAMAIS partager)
# ~/.ssh/xpeditis_hetzner.pub  (clé publique — à ajouter sur Hetzner)

# Vérification
cat ~/.ssh/xpeditis_hetzner.pub
# ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI... xpeditis-hetzner-deploy
```

Ajoutez la clé publique dans `~/.ssh/config` pour faciliter la connexion :

```bash
cat >> ~/.ssh/config << 'EOF'
Host hetzner-xpeditis-*
    IdentityFile ~/.ssh/xpeditis_hetzner
    User root
    StrictHostKeyChecking no
EOF
```

---

## Nom de domaine

Vous avez besoin d'un domaine avec accès à la gestion DNS. Ce guide suppose :

| Domaine | Usage |
|---|---|
| `xpeditis.com` (ou votre domaine) | Site principal |
| `api.xpeditis.com` | API NestJS backend |
| `app.xpeditis.com` | Frontend Next.js |
| `monitoring.xpeditis.com` | Grafana (optionnel, accès restreint) |

**Si vous n'avez pas encore de domaine :** Namecheap (~$10/an) ou OVHcloud (~€7/an). Une fois acheté, déléguez les DNS à Cloudflare (gratuit, meilleur outil DNS).

### Déléguer le DNS à Cloudflare

1. Créez un compte sur https://cloudflare.com
2. "Add a Site" → entrez votre domaine
3. Cloudflare scanne vos DNS existants
4. Copiez les 2 nameservers Cloudflare (ex: `carl.ns.cloudflare.com`)
5. Chez votre registrar, remplacez les nameservers par ceux de Cloudflare
6. Attendez 5-30 min pour la propagation

---

## Variables d'environnement de travail

Créez un fichier `.env.deploy` (ne pas committer) pour centraliser vos variables de déploiement :

```bash
# Fichier : ~/.xpeditis-deploy.env
# Source ce fichier avant de travailler : source ~/.xpeditis-deploy.env

# Hetzner
export HCLOUD_TOKEN="<votre_token_hetzner>"
export HETZNER_SSH_KEY_PATH="$HOME/.ssh/xpeditis_hetzner"

# Kubernetes
export KUBECONFIG="$HOME/.kube/kubeconfig-xpeditis-prod"

# Domaine
export DOMAIN="xpeditis.com"
export API_DOMAIN="api.xpeditis.com"
export APP_DOMAIN="app.xpeditis.com"

# Registry Docker (GitHub Container Registry)
export GHCR_REGISTRY="ghcr.io"
export GHCR_ORG="<votre_org_github>"
export BACKEND_IMAGE="$GHCR_REGISTRY/$GHCR_ORG/xpeditis-backend"
export FRONTEND_IMAGE="$GHCR_REGISTRY/$GHCR_ORG/xpeditis-frontend"

# PostgreSQL (Neon.tech)
export DATABASE_URL="postgresql://user:pass@host/dbname?sslmode=require"

# Redis (Upstash)
export REDIS_HOST="your-redis.upstash.io"
export REDIS_PORT="6379"
export REDIS_PASSWORD="<upstash_redis_password>"

# Hetzner Object Storage
export HETZNER_S3_BUCKET="xpeditis-prod"
export HETZNER_S3_ENDPOINT="https://fsn1.your-objectstorage.com"
export HETZNER_S3_ACCESS_KEY="<access_key>"
export HETZNER_S3_SECRET_KEY="<secret_key>"
```

---

## Checklist avant de démarrer

```
□ Compte Hetzner Cloud créé et vérifié (CB enregistrée)
□ Compte GitHub avec repo xpeditis2.0 (ou fork)
□ Compte Cloudflare avec domaine délégué
□ Compte Neon.tech créé
□ Compte Upstash créé (optionnel)
□ kubectl installé (>= 1.28)
□ helm installé (>= 3.12)
□ hcloud CLI installé et configuré
□ hetzner-k3s installé
□ Paire de clés SSH ED25519 générée pour Hetzner
□ Docker installé (pour build local)
□ Domaine + sous-domaines api. et app. planifiés
```

---

## Configuration hcloud CLI

```bash
# Configurer le token Hetzner
hcloud context create xpeditis-prod
# Entrez votre token quand demandé

# Vérifier la configuration
hcloud context list
hcloud server list  # Doit retourner une liste vide (ou vos serveurs)

# Lister les types de serveurs disponibles
hcloud server-type list

# Lister les images disponibles
hcloud image list --type system | grep ubuntu
```

---

## Vérification finale

```bash
# Tous ces checks doivent passer avant de continuer
echo "=== Vérification des outils ==="
kubectl version --client --short 2>/dev/null && echo "✅ kubectl OK" || echo "❌ kubectl manquant"
helm version --short 2>/dev/null && echo "✅ helm OK" || echo "❌ helm manquant"
hcloud version 2>/dev/null && echo "✅ hcloud OK" || echo "❌ hcloud manquant"
hetzner-k3s version 2>/dev/null && echo "✅ hetzner-k3s OK" || echo "❌ hetzner-k3s manquant"
docker --version 2>/dev/null && echo "✅ docker OK" || echo "❌ docker manquant"
ssh-keygen -l -f ~/.ssh/xpeditis_hetzner.pub 2>/dev/null && echo "✅ SSH key OK" || echo "❌ Clé SSH manquante"

echo ""
echo "=== Vérification des tokens ==="
hcloud context list 2>/dev/null | grep xpeditis && echo "✅ hcloud context OK" || echo "❌ hcloud context non configuré"
```