📖 Manuel

Edge Computing Designer

Workflow

1. Évaluation des contraintes

Avant toute architecture, répondre à ces questions :

2. Découpage edge / fog / cloud

[Capteurs] → [Edge node] → [Fog gateway] → [Cloud]
               ↓ inférence       ↓ agrégation    ↓ analytics
               ↓ filtrage        ↓ buffer         ↓ modèles ML
               local < 10 ms     local < 500 ms   batch

• Edge node : Raspberry Pi 5, NVIDIA Jetson Orin, Coral Dev Board, PLC industriel
• Fog gateway : x86 mini-PC, routeur industriel (Moxa, Advantech)
• Cloud : AWS Greengrass hub, Azure IoT Hub, GCP Cloud IoT (ou on-prem)

Règle d'affectation : si la décision doit se prendre en < 100 ms ou si la donnée n'a pas de valeur au-delà du site, elle reste en edge. Tout le reste monte au cloud.

3. Sélection matérielle

Charge de calcul faible  → Raspberry Pi 5 (8 Go) + Coral USB Accelerator
Vision par ordinateur    → NVIDIA Jetson Orin NX (16 Go, 100 TOPS)
Industrie / -40°C/+85°C → Advantech MIC-720AI ou Moxa V2406C
Ultra-faible conso       → ESP32-S3 (inférence ML embarquée, ~240 MHz)

Checklist matérielle :

• [ ] Température opérationnelle compatible avec le site
• [ ] Stockage suffisant pour le buffer offline (min. 24 h de données)
• [ ] Watchdog hardware pour redémarrage automatique
• [ ] Interface réseau redondante (LTE + Ethernet)

4. Architecture offline-first

Toute application edge doit persister localement avant d'envoyer au cloud.

Pattern Store-and-Forward avec SQLite :

import sqlite3, time, requests

DB = "/data/edge.db"

def init_db():
    with sqlite3.connect(DB) as cx:
        cx.execute("""
            CREATE TABLE IF NOT EXISTS queue (
                id INTEGER PRIMARY KEY,
                payload TEXT,
                created_at REAL,
                sent INTEGER DEFAULT 0
            )
        """)

def enqueue(payload: str):
    with sqlite3.connect(DB) as cx:
        cx.execute("INSERT INTO queue (payload, created_at) VALUES (?,?)",
                   (payload, time.time()))

def flush_to_cloud(endpoint: str):
    with sqlite3.connect(DB) as cx:
        rows = cx.execute(
            "SELECT id, payload FROM queue WHERE sent=0 ORDER BY id LIMIT 100"
        ).fetchall()
        if not rows:
            return
        ids = [r[0] for r in rows]
        batch = [r[1] for r in rows]
        try:
            requests.post(endpoint, json=batch, timeout=10)
            cx.execute(f"UPDATE queue SET sent=1 WHERE id IN ({','.join('?'*len(ids))})", ids)
        except Exception:
            pass  # retry au prochain cycle

Gestion des conflits : utiliser des timestamps logiques (Lamport clock) ou des CRDTs pour les données métriques. Pour les commandes, FIFO strict + idempotency key.

5. Synchronisation cloud

# MQTT avec rétention locale — Eclipse Mosquitto + store-and-forward
mosquitto.conf :
  persistence true
  persistence_location /var/lib/mosquitto/
  queue_qos0_messages true
  max_queued_messages 10000

# Publier avec QoS 1 (at-least-once) pour garantie de livraison
mosquitto_pub -h broker -t "site/sensor/temp" -m '{"v":42.1}' -q 1

Delta sync : n'envoyer que les changements significatifs (dead-band filtering).

DEAD_BAND = 0.5  # °C

last_sent = None
def should_send(value):
    global last_sent
    if last_sent is None or abs(value - last_sent) >= DEAD_BAND:
        last_sent = value
        return True
    return False

6. Déploiement de modèles ML en edge

# Convertir un modèle PyTorch → TFLite optimisé
python -c "
import torch, torch.onnx
model.eval()
torch.onnx.export(model, dummy_input, 'model.onnx', opset_version=17)
"

# Quantiser en INT8 pour Coral / Jetson
tflite_convert \
  --saved_model_dir=./saved_model \
  --output_file=model_quant.tflite \
  --optimizations=DEFAULT \
  --inference_input_type=INT8 \
  --inference_output_type=INT8

# Inférence ONNX Runtime (edge x86/ARM)
import onnxruntime as ort
sess = ort.InferenceSession("model.onnx", providers=["CPUExecutionProvider"])
result = sess.run(None, {"input": data})

Cible : modèle < 5 MB, inférence < 20 ms sur CPU ARM Cortex-A55.

7. OTA et orchestration de flotte

# Mender.io — déploiement OTA signé avec rollback automatique
mender-artifact write rootfs-image \
  --device-type raspberry-pi-5 \
  --artifact-name firmware-2.4.1 \
  --file rootfs.img \
  --output-path firmware-2.4.1.mender

# Vérification d'intégrité post-déploiement (health check)
mender install firmware-2.4.1.mender && mender commit || mender rollback

Alternatives : Balena Fleet (containers), AWS Greengrass v2, Azure IoT Edge modules.

Règle OTA : déployer en canary (5 % de la flotte → 48 h de monitoring → 100 %). Ne jamais mettre à jour bootloader et application en même artefact.

8. Sécurité edge

# Boot sécurisé Raspberry Pi (config.txt)
program_usb_boot_mode=0
# + HAT TPM2.0 pour stockage de clés

# Chiffrement partition données
cryptsetup luksFormat /dev/mmcblk0p3
cryptsetup open /dev/mmcblk0p3 data_enc
mkfs.ext4 /dev/mapper/data_enc

# mTLS entre edge et cloud (certificats x.509)
mosquitto_pub --cafile ca.crt --cert edge.crt --key edge.key \
  -h broker -p 8883 -t "data" -m "payload"

Checklist sécurité :

• [ ] Certificats uniques par appareil (pas de clé partagée)
• [ ] Rotation des certificats automatisée (< 1 an)
• [ ] Firewall local : seuls ports MQTT (8883) et SSH (via bastion) ouverts
• [ ] Logs tamper-evident (append-only, hash chaîné)

9. Monitoring distribué

# Prometheus Node Exporter sur chaque edge node
# prometheus.yml (scrape depuis fog gateway)
scrape_configs:
  - job_name: 'edge_nodes'
    static_configs:
      - targets: ['192.168.1.10:9100', '192.168.1.11:9100']
    scrape_interval: 30s

# Alerte Grafana : nœud silencieux depuis > 5 min
alert: EdgeNodeDown
expr: up{job="edge_nodes"} == 0
for: 5m

Métriques indispensables : CPU/mémoire/température, taille de la queue locale, latence d'inférence, dernière synchronisation réussie.

Anti-patterns et pièges

Bonnes pratiques 2026

• WebAssembly en edge : WASM + WASI pour déployer du code portable sur n'importe quel runtime edge (Wasmtime, WasmEdge) — isolation sandbox sans conteneur lourd.
• tinyML : modèles < 256 KB pour microcontrôleurs (TensorFlow Micro, Edge Impulse) — inférence sur ESP32 sans OS.
• Matter / Thread : protocole standard pour la couche réseau IoT locale (2026) — préférer à Zigbee propriétaire pour l'interopérabilité.
• Edge AI lifecycle : versionner les modèles edge comme du code (DVC + MLflow) et tracer chaque version déployée par appareil.
• eBPF sur gateway Linux : filtrage de paquets et observabilité réseau sans overhead kernel pour les passerelles Fog.