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

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)

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

# 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

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

# 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})

# 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

# 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"

# 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