# Preparation de la carte Gold (image maitre)

<div style="background: linear-gradient(135deg, #f57f17 0%, #e65100 100%); color: white; padding: 24px; border-radius: 12px; margin-bottom: 24px;">
<h2 style="margin:0; color: white;">Document reserve au responsable technique</h2>
<p style="margin: 8px 0 0 0; opacity: 0.9;">Cette procedure ne se fait qu'une seule fois. Elle produit l'image maitre qui sera clonee pour chaque nouveau client.</p>
</div>

---

## Qu'est-ce que la carte Gold ?

La carte Gold est une carte SD **de reference** contenant :

- Le systeme d'exploitation (JetPack / Linux)
- Les drivers GPU (CUDA, cuDNN, TensorRT)
- SmartEye complet (YOLO, modeles IA, services)
- **Aucune configuration client** (pas de cameras, pas de compte, pas de logs)

C'est l'equivalent de l'image usine d'une box Free ou Orange. Le Jetson qui demarre avec cette carte arrive directement en **mode installation**, pret a etre configure depuis un smartphone.

---

## Principe : on ne touche JAMAIS a la carte de dev

```
Carte actuelle (DEV/Aleria)          Carte neuve n°1             Carte neuve n°2, 3, 4...
┌─────────────────────┐              ┌─────────────┐            ┌─────────────┐
│ SmartEye + Demo_01  │──── clone ──→│ Copie brute │            │             │
│ Cameras configurees │              │ (tout dedans)│            │             │
│ Logs, images, etc.  │              └──────┬──────┘            │  Client X   │
│                     │                     │                    │             │
│  ON N'Y TOUCHE PAS  │              nettoyage config            │             │
│                     │              suppression logs            └─────────────┘
└─────────────────────┘              suppression images                ▲
                                            │                         │
                                            ▼                         │
                                     ┌──────────────┐          clone a l'infini
                                     │  CARTE GOLD  │────────────────┘
                                     │  (mode usine)│
                                     └──────────────┘
```

!!! warning "Regle d'or"
    La carte du Jetson de developpement (Aleria/Demo_01) **reste en place, intacte**. On la clone d'abord, puis on nettoie le clone. Comme ca, si quelque chose se passe mal, le Jetson de dev est toujours operationnel.

---

## Pre-requis

| Element | Detail |
|---------|--------|
| **Jetson de dev** | Le Jetson actuel (Aleria) qui fonctionne |
| **Carte SD neuve** | 64 Go minimum, classe A2/U3 |
| **PC Linux ou Mac** | Pour cloner et nettoyer |
| **Lecteur de carte SD** | USB ou integre |
| **Espace disque** | ~64 Go libres sur le PC |
| **Balena Etcher** | [balena.io/etcher](https://www.balena.io/etcher/) (gratuit) |

---

!!! danger "Carte SD de reference"
    La carte originale du Jetson de dev est une **Samsung EVO 128 Go**.
    Les cartes clones doivent etre de capacite **egale ou superieure** et idealement de la meme marque.
    Deux cartes "128 Go" de marques differentes n'ont pas exactement la meme taille en octets.
    Si la carte clone est plus petite (meme de quelques Mo), le clone sera corrompu et ne bootera pas.

## Etape 1 — Cloner la carte actuelle (telle quelle)

Eteindre le Jetson de dev proprement :

```bash
# Sur le Jetson
sudo shutdown -h now
# Attendre extinction complete (LED eteintes)
```

Retirer la carte SD et l'inserer dans le lecteur du PC.

=== "Linux"

    ```bash
    # Identifier la carte SD
    lsblk

    # Cloner la carte entiere (NE RIEN MODIFIER)
    sudo dd if=/dev/sdb of=$HOME/smarteye-dev-backup.img bs=4M status=progress

    # Compresser le backup
    gzip $HOME/smarteye-dev-backup.img
    ```

=== "Mac"

    ```bash
    # Identifier la carte SD
    diskutil list

    # Demonter sans ejecter
    diskutil unmountDisk /dev/disk4

    # Cloner (~ 1h pour une carte 128 Go)
    sudo dd if=/dev/rdisk4 of=/Users/$(whoami)/smarteye-dev-backup.img bs=4m status=progress

    # Compresser
    gzip /Users/$(whoami)/smarteye-dev-backup.img
    ```

    !!! tip "Pourquoi `/Users/$(whoami)/` et pas `~/` ?"
        Avec `sudo`, le `~` pointe vers `/var/root/` au lieu de votre dossier utilisateur. `$(whoami)` resout ce probleme en inserant automatiquement votre nom d'utilisateur.

!!! tip "Conserver ce backup"
    Le fichier `smarteye-dev-backup.img.gz` est votre **sauvegarde de securite** du Jetson de dev. Gardez-le precieusement. En cas de probleme, vous pouvez toujours reflasher la carte d'origine.

**Remettre immediatement la carte dans le Jetson de dev** et le redemarrer. Il reprend son fonctionnement normal.

---

## Etape 2 — Flasher le clone sur une carte neuve

Inserer une **carte SD neuve** (128 Go) dans le lecteur.

=== "Balena Etcher (recommande)"

    1. Ouvrir Balena Etcher
    2. **Flash from file** → selectionner `smarteye-dev-backup.img.gz`
    3. **Select target** → selectionner la carte SD neuve
    4. **Flash!** → attendre ~10 minutes

=== "Linux"

    ```bash
    # 1. Verifier que la carte neuve est detectee
    lsblk
    # Reperer la carte neuve par sa taille (ex: /dev/sdb, 128 Go)

    # 2. Flasher
    gunzip -c $HOME/smarteye-dev-backup.img.gz | sudo dd of=/dev/sdb bs=4M status=progress
    sync
    ```

=== "Mac"

    ```bash
    # 1. Verifier que la carte neuve est detectee
    diskutil list
    # Reperer la carte par sa taille (ex: /dev/disk4, 134.2 GB = 128 Go)

    # 2. Demonter la carte sans l'ejecter
    diskutil unmountDisk /dev/disk4

    # 3. Flasher (~ 1h pour 128 Go, adapter /dev/rdisk4 si necessaire)
    gunzip -c /Users/$(whoami)/smarteye-dev-backup.img.gz | sudo dd of=/dev/rdisk4 bs=4m status=progress
    ```

    !!! info "Pourquoi 3 commandes separees ?"
        - `diskutil list` → **verifier** qu'on cible la bonne carte (pas le disque du Mac !)
        - `diskutil unmountDisk` → **liberer** la carte pour que `dd` puisse y ecrire
        - `gunzip -c ... | dd` → **decompresser et flasher** en une seule passe

A ce stade, la carte neuve est une **copie exacte** de la carte de dev (avec Demo_01, les cameras, les logs — tout).

---

## Etape 3 — Nettoyer le clone (le transformer en Gold)

Inserer la carte neuve (le clone) dans le Jetson **ou** la monter sur le PC pour nettoyer.

### Option A : Nettoyer depuis le Jetson

Inserer la carte clone dans un Jetson, le demarrer, puis :

```bash
# 1. Arreter SmartEye
sudo systemctl stop smarteye

# 2. Supprimer la configuration client (Demo_01)
rm -f /w/smarteye_config.yaml

# 3. Supprimer toutes les images capturees
rm -rf /w/runs/*

# 4. Supprimer les logs
rm -rf /w/logs/*
rm -f /w/*.log

# 5. Nettoyer les known_hosts SSH (specifiques au site)
rm -f ~/.ssh/known_hosts

# 6. Vider l'historique bash
history -c
> ~/.bash_history
```

### Option B : Nettoyer depuis le PC (sans Jetson)

Si vous n'avez qu'un seul Jetson, monter la carte sur le PC :

```bash
# Monter la partition principale de la carte SD
sudo mount /dev/sdb1 /mnt

# Nettoyer (adapter les chemins selon la structure)
sudo rm -f /mnt/home/*/w/smarteye_config.yaml
sudo rm -rf /mnt/home/*/w/runs/*
sudo rm -rf /mnt/home/*/w/logs/*
sudo rm -f /mnt/home/*/.ssh/known_hosts
sudo rm -f /mnt/home/*/.bash_history

# Demonter
sudo umount /mnt
```

### Verification du nettoyage

```
=== Verification ===
Config client :   ABSENT ✓
Images :          0 fichiers ✓
Logs :            0 fichiers ✓
known_hosts :     ABSENT ✓
```

---

## Etape 4 — Verifier le mode setup

Si vous avez nettoye depuis le Jetson (Option A), verifier que SmartEye demarre en mode installation :

```bash
sudo systemctl start smarteye
curl http://localhost:8080/api/identity
```

Reponse attendue :

```json
{
  "type": "smarteye",
  "version": "v30",
  "status": "setup",
  "message": "En attente de configuration"
}
```

Puis eteindre :

```bash
sudo shutdown -h now
```

---

## Etape 5 — Creer l'image Gold definitive

Retirer la carte nettoyee du Jetson et la recloner en tant que **Gold** :

=== "Linux"

    ```bash
    # La carte nettoyee est dans le lecteur
    lsblk
    sudo dd if=/dev/sdb of=$HOME/smarteye-gold-v30.img bs=4M status=progress
    gzip $HOME/smarteye-gold-v30.img

    # Resultat final
    ls -lh $HOME/smarteye-gold-v30.img.gz
    ```

=== "Mac"

    ```bash
    # La carte nettoyee est dans le lecteur
    diskutil list
    diskutil unmountDisk /dev/disk4

    sudo dd if=/dev/rdisk4 of=/Users/$(whoami)/smarteye-gold-v30.img bs=4m status=progress
    gzip /Users/$(whoami)/smarteye-gold-v30.img

    # Resultat final
    ls -lh /Users/$(whoami)/smarteye-gold-v30.img.gz
    ```

!!! success "Votre image Gold est prete"
    Le fichier `smarteye-gold-v30.img.gz` est votre image maitre. C'est a partir de ce fichier que vous [clonerez chaque nouveau Jetson](clonage.md).

---

## Resume des cartes

| Carte | Contenu | Usage |
|-------|---------|-------|
| **Carte de dev** | SmartEye + Demo_01 + cameras | Reste dans le Jetson de dev, **jamais modifiee** |
| **Backup dev** | `smarteye-dev-backup.img.gz` | Sauvegarde de securite, au cas ou |
| **Image Gold** | `smarteye-gold-v30.img.gz` | Image vierge, **source de tous les clones** |
| **Carte client** | Flashee depuis la Gold | Une par client, configuree sur site |

---

## Checklist finale

- [ ] Carte de dev clonee → `smarteye-dev-backup.img.gz`
- [ ] Carte de dev remise dans le Jetson, fonctionnement verifie
- [ ] Clone flashe sur carte neuve
- [ ] Clone nettoye (pas de config, pas d'images, pas de logs)
- [ ] Mode setup verifie (JSON "status: setup")
- [ ] Clone nettoye reclone → `smarteye-gold-v30.img.gz`
- [ ] Image Gold stockee en lieu sur

---

## Ou stocker les images ?

| Fichier | Taille estimee | Ou le garder |
|---------|:--------------:|--------------|
| `smarteye-dev-backup.img.gz` | ~8-15 Go | PC + disque externe |
| `smarteye-gold-v30.img.gz` | ~8-15 Go | PC + disque externe + serveur OVH |

!!! info "Versionnement"
    A chaque mise a jour de SmartEye, creer une nouvelle image Gold :

    ```
    smarteye-gold-v30-2026-02-21.img.gz   ← actuelle
    smarteye-gold-v31-2026-03-15.img.gz   ← apres mise a jour
    ```

---

## Etape suivante

→ [Cloner et deployer un nouveau Jetson](clonage.md)
