Passer de 1 à 100 stations de test

Exploitez une station ou une centaine : TofuPilot gère les deux, mais les décisions d'architecture prises à 10 stations déterminent votre succès à 100. Ce guide présente les changements nécessaires à chaque seuil de montée en charge.

Défis de montée en charge par étape

Stations	Ce qui casse	Cause racine
1	Rien	Tout va bien
5-10	Dérive de configuration	Configuration manuelle par station
10-25	Désynchronisation des versions de scripts	Absence de pipeline de déploiement
25-50	Perte de visibilité pour le débogage	Pas de journalisation centralisée
50-100	Saturation réseau	Toutes les stations contactent le cloud simultanément
100+	Collision d'identifiants	Noms de stations non uniques

Architecture à chaque échelle

1 station

Une seule machine exécutant votre script de test. Aucune infrastructure particulière n'est nécessaire.

[DUT] -> [Station de test] -> [TofuPilot Cloud]

10 stations

À 10 stations, le goulot d'étranglement est la configuration. Il vous faut une source de configuration partagée, un nommage cohérent et un moyen de déployer les mises à jour de scripts.

[10 DUTs] -> [10 stations de test] -> [TofuPilot Cloud]
                    |
              [Dépôt Git pour les scripts]

100 stations

À 100 stations, vous avez besoin d'un pipeline de déploiement, d'une surveillance centralisée et d'un échelonnement des envois.

[100 DUTs] -> [100 stations de test] -> [TofuPilot Cloud]
                    |                       |
             [Pipeline CI/CD]        [Tableau de bord de santé]
             [Serveur de configuration]

Nommage et enregistrement des stations

TofuPilot identifie les stations par leur nom. Une collision corrompt les analyses par station.

{site}-{ligne}-{numéro_station}
# Exemples :
taipei-line1-001
munich-eol-001

Définissez le nom de la station comme variable d'environnement :

/etc/environment

TOFUPILOT_STATION_ID=taipei-line1-001
TOFUPILOT_API_KEY=tp_live_xxxxxxxxxxxx

Distribution des scripts de test

Option 1 : Git Pull (1-20 stations)

/etc/cron.d/update-test-script

0 6 * * * testuser cd /opt/testscripts && git pull origin main

Avantages : Simple. Inconvénients : Nécessite un accès réseau à l'hébergeur Git. Échoue silencieusement.

Option 2 : Binaire PyInstaller (20-50 stations)

build_and_deploy.sh

#!/bin/bash
pyinstaller --onefile test_main.py --name test_runner

for station in taipei-line1-{001..020}; do
  rsync -az dist/test_runner "${station}:/opt/testscripts/test_runner_new"
  ssh "${station}" "mv /opt/testscripts/test_runner_new /opt/testscripts/test_runner"
done

Avantages : Pas de Python sur les stations. Inconvénients : Itération plus lente, binaire plus volumineux.

Option 3 : Docker (50-100 stations)

Dockerfile

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY test_main.py .
CMD ["python", "test_main.py"]

docker-compose.yml

version: "3.9"
services:
  test_runner:
    image: your-registry/test-runner:latest
    restart: unless-stopped
    environment:
      - TOFUPILOT_STATION_ID
      - TOFUPILOT_API_KEY
    devices:
      - /dev/ttyUSB0:/dev/ttyUSB0

Mettre à jour toutes les stations :

deploy.sh

#!/bin/bash
parallel-ssh -h stations.txt "docker compose pull && docker compose up -d"

Comparaison des méthodes de distribution

Méthode	Stations	Python sur la station	Vitesse de mise à jour	Retour arrière
Git pull	1-20	Oui	Rapide	`git revert`
PyInstaller	20-50	Non	Moyenne	Remplacement du binaire
Docker	50-100	Non	Rapide	Tag d'image précédent

Configuration centralisée

Ne codez jamais en dur les valeurs qui varient par station ou par produit.

Niveau de configuration	Portée	Exemple
Variable d'environnement	Par station	`TOFUPILOT_STATION_ID`, `TOFUPILOT_API_KEY`
Fichier de configuration	Par produit	Limites de tension, seuils de temporisation
Script de test	Par phase de test	Logique de phase OpenHTF

config/product_v2.yaml

voltage_rail_3v3:
  min: 3.2
  max: 3.4
voltage_rail_5v:
  min: 4.8
  max: 5.2
boot_time_ms:
  min: 0
  max: 3000

test_main.py

import yaml
import openhtf as htf
from openhtf.util import units
from tofupilot.openhtf import TofuPilot

with open("config/product_v2.yaml") as f:
    cfg = yaml.safe_load(f)

@htf.measures(
    htf.Measurement("voltage_3v3").in_range(
        cfg["voltage_rail_3v3"]["min"],
        cfg["voltage_rail_3v3"]["max"]
    ).with_units(units.VOLT)
)
def phase_power_check(test):
    voltage = read_voltage_rail("3v3")
    test.measurements.voltage_3v3 = voltage

Topologie réseau

Les stations communiquent uniquement en sortie vers TofuPilot. Aucun port entrant n'est requis.

Destination	Port	Objectif
`tofupilot.app`	443	Envoi des résultats de test
Votre hébergeur Git	443	Mises à jour des scripts
Votre registre de conteneurs	443	Téléchargement des images

À 100 stations, échelonnez les envois pour éviter l'effet de troupeau :

upload_utils.py

import time
import random

def upload_with_jitter(upload_fn, max_jitter_seconds=10):
    time.sleep(random.uniform(0, max_jitter_seconds))
    upload_fn()

Surveillance de la santé des stations

TofuPilot suit automatiquement le rendement, le débit et la durée des tests par station. Ouvrez l'onglet Analytics filtré par station pour détecter les dégradations.

Liste de contrôle de santé des stations

Vérification	Intervalle	Action en cas de défaillance
Signal de vie vers TofuPilot	1 min	Alerter l'astreinte, vérifier le réseau
Version du script de test	Au démarrage	Mise à jour automatique via le pipeline
Espace disque	1 heure	Archiver les anciens journaux, alerter si inférieur à 5 Go
Connectivité USB de la fixture	Avant chaque test	Échouer le test avec une erreur explicite

Script d'initialisation de station

bootstrap.sh

#!/bin/bash
set -e

STATION_ID=$1
API_KEY=$2

if [ -z "$STATION_ID" ] || [ -z "$API_KEY" ]; then
  echo "Usage: bootstrap.sh <station-id> <api-key>"
  exit 1
fi

echo "TOFUPILOT_STATION_ID=${STATION_ID}" >> /etc/environment
echo "TOFUPILOT_API_KEY=${API_KEY}" >> /etc/environment

curl -fsSL https://get.docker.com | sh

mkdir -p /opt/testrunner
cat > /opt/testrunner/docker-compose.yml << EOF
version: "3.9"
services:
  test_runner:
    image: your-registry/test-runner:latest
    restart: unless-stopped
    env_file: /etc/environment
EOF

docker compose -f /opt/testrunner/docker-compose.yml up -d
echo "La station ${STATION_ID} est en cours d'exécution."

terminal

sudo bash bootstrap.sh taipei-line1-042 tp_live_xxxxxxxxxxxx