P
Parsyn/Docs
Retour à l'accueil

Configuration des Workers

Connecter vos propres machines GPU a la plateforme Parsyn. Installation, configuration, gestion de flotte et resolution de problemes.

Pourquoi connecter vos propres workers

Les Parsyn Workers (GPU geres par la plateforme) sont le moyen le plus rapide de lancer un entrainement, mais connecter vos propres machines vous offre :

  • Aucun cout en credits : Vous payez votre materiel et votre electricite, pas des credits a l'heure.
  • Capacite d'inference : Les Parsyn Workers ne gerent que le fine-tuning. Pour discuter avec vos modeles, il vous faut vos propres workers.
  • Controle des donnees : Vos machines GPU peuvent rester sur votre propre reseau. Les poids du modele transitent par le stockage S3, mais le calcul reste sur votre materiel.
  • Disponibilite permanente : Pas de limite de capacite. Vos machines sont a vous.

Prerequis

  • Un GPU NVIDIA avec ses pilotes installes
  • 8 Go+ de VRAM (16 Go+ recommandes pour un 7B en LoRA)
  • Linux, ou Windows avec WSL2
  • Acces internet vers parsyn.progatis.com (WebSocket + HTTPS)

Ni Python ni toolkit CUDA a installer : le worker tourne depuis une image de conteneur qui embarque son propre environnement. Les pilotes sont la seule chose que l'installateur ne touchera pas — verifiez que les votres repondent : 

nvidia-smi

Installation

Une commande sur la machine equipee du GPU :

curl -fsSL https://get.parsyn.progatis.com/worker | sh

Elle installe Docker et le toolkit conteneur NVIDIA s'ils manquent, puis la commande parsyn, puis recupere l'image du worker. Ensuite : 

parsyn init     # pose deux questions
parsyn start    # se connecte et s'enrole
parsyn logs -f  # suivre
parsyn doctor   # diagnostiquer, si quelque chose cloche

parsyn init demande votre cle d'enrolement a l'invite plutot que de la prendre en argument, pour qu'elle ne passe pas par l'historique du shell. Creez la cle depuis Workers → Ajouter une machine dans le tableau de bord, qui affiche ces memes trois commandes.

Installation sans surveillance

Pour cloud-init, Ansible ou la construction d'une image, parsyn init accepte la meme configuration sans rien demander. La cle arrive sur l'entree standard pour la raison qui fait qu'elle n'est pas un drapeau : une ligne de commande est visible dans ps pendant son execution. 

curl -fsSL https://get.parsyn.progatis.com/worker | sh
printf '%s' "$PARSYN_KEY" | parsyn init --key-stdin --non-interactive   --name gpu-box-1
parsyn start

parsyn init --help liste toutes les options, dont --url pour une plateforme auto-hebergee et --force pour remplacer une configuration existante.

Enregistrer un worker

Avant de pouvoir se connecter, un worker doit etre enregistre sur la plateforme. Deux options :

Cle d'enrolement

Creez une cle d'enrolement depuis la page Enrollment Keys du dashboard : 

curl -X POST https://parsyn.progatis.com/api/v1/master-keys \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "datacenter-east-fleet",
    "description": "Auto-enrollment for east datacenter",
    "auto_name_prefix": "east-worker",
    "default_worker_type": "both",
    "max_enrollments": 50
  }'

La cle d'enrolement (format : enroll_...) peut etre partagee avec autant de machines que necessaire. Lors de la premiere connexion, chaque worker s'enregistre automatiquement et recoit sa propre cle individuelle (format : wkr_...). Le worker l'ecrit dans son fichier .env sous WORKER_API_KEY et la reutilise aux demarrages suivants, sans repasser par l'enrolement.

C'est l'approche recommandee pour deployer des workers a grande echelle. Integrez la master key d'enrollment dans votre script de provisioning ou votre image machine, et les nouvelles machines s'enregistrent d'elles-memes.

Configuration

Les workers sont configures via des variables d'environnement : 

# Connexion (obligatoire)
PLATFORM_URL=wss://parsyn.progatis.com/ws/worker
WORKER_ENROLLMENT_KEY=enroll_xyz789...    # a la premiere installation
WORKER_API_KEY=wkr_abc123...              # ecrit automatiquement apres enrolement

# GPU
GPU_DEVICE=cuda:0
MAX_BATCH_SIZE=32

# Comportement du worker
WORKER_TYPE=both          # fine_tuner, prompter, ou both
HEARTBEAT_INTERVAL=30     # Secondes entre les heartbeats
RECONNECT_DELAY=5         # Delai initial de reconnexion

# Performance
QUANTIZATION=none         # none, 4bit, ou 8bit pour l'inference
TRUST_REMOTE_CODE=false   # Autoriser les modeles HF avec du code custom

# Stockage
CACHE_DIR=~/.cache/parsyn
LOG_LEVEL=INFO

Reference complete de configuration

VariableObligatoireDefautDescription
PLATFORM_URLOuiURL WebSocket. Utilisez wss://parsyn.progatis.com/ws/worker pour la plateforme hebergee.
WORKER_API_KEYOui*API key individuelle obtenue par enregistrement manuel.
WORKER_ENROLLMENT_KEYOui*Master key pour l'auto-enrollment a la premiere connexion.
GPU_DEVICENoncuda:0Peripherique CUDA. cuda:1 pour le second GPU, etc.
MAX_BATCH_SIZENon32Limite haute de la taille de batch que le worker acceptera.
WORKER_TYPENonbothfine_tuner (fine-tuning uniquement), prompter (inference uniquement) ou both.
QUANTIZATIONNonnoneCharger les modeles quantifies pour l'inference. Reduit la VRAM au prix d'une legere perte de qualite.
TRUST_REMOTE_CODENonfalseAutoriser les modeles avec du code Python custom provenant de HuggingFace. Risque de securite, a activer uniquement pour des modeles de confiance.
CACHE_DIRNon~/.cache/parsynCache local pour les modeles et datasets telecharges.
TRAINING_TIMEOUT_SECONDSNon86400Duree maximale d'entrainement par job (24 heures).
INFERENCE_TIMEOUT_SECONDSNon300Duree maximale d'inference par requete (5 minutes).
MAX_INFERENCE_CACHED_MODELSNon2Nombre de modeles conserves en memoire GPU pour un changement de modele rapide en inference.

* L'une des deux variables WORKER_API_KEY ou WORKER_ENROLLMENT_KEY est obligatoire.

Demarrer le worker

parsyn-worker start

Au demarrage, le worker :

  1. Determine son API key (cle individuelle, identifiants caches d'un enrollment precedent, ou master key d'enrollment)
  2. Se connecte a la plateforme via WebSocket
  3. S'authentifie et (en cas d'enrollment) recoit son API key individuelle
  4. Lance un benchmark GPU (mis en cache pendant 24 heures)
  5. Envoie les informations materielles et les resultats du benchmark a la plateforme
  6. Demarre la boucle de heartbeat (toutes les 30 s) et la boucle de metriques (toutes les 5 s)
  7. Attend des taches

Sortie attendue :

INFO  Worker abc12345 connecting to wss://parsyn.progatis.com/ws/worker
INFO  Connected to platform
INFO  Running GPU benchmark...
INFO  Benchmark complete: score=85.2, TFLOPS=82.6, bandwidth=1008 GB/s
INFO  Registered: NVIDIA A100-SXM4-80GB, 80 GB VRAM, CUDA 12.1
INFO  Worker ready, waiting for tasks...

Benchmark GPU

A la premiere connexion (puis toutes les 24 heures), le worker execute un benchmark GPU automatise. La plateforme utilise les scores du benchmark pour l'assignation intelligente des jobs en mode auto, en attribuant chaque job au worker le plus performant disponible.

Le benchmark mesure :

  • TFLOPS : Debit de multiplication de matrices en FP16
  • Bande passante memoire : Vitesse de transfert de tenseurs volumineux (Go/s)
  • Taille de batch maximale : Recherche binaire du plus grand batch tenant en memoire
  • Score composite : Combinaison ponderee (50 % TFLOPS, 30 % bande passante, 20 % VRAM), normalisee par rapport a une RTX 4090 de reference

Si le benchmark depasse le delai d'attente (60 secondes), le worker utilise des valeurs de repli conservatives et se signale quand meme a la plateforme.

Executer en tant que service systeme

En production, utilisez systemd pour que le worker demarre au boot et redemarre automatiquement en cas d'echec : 

[Unit]
Description=Parsyn Training Worker
After=network.target

[Service]
Type=simple
User=parsyn
WorkingDirectory=/opt/parsyn-worker
EnvironmentFile=/opt/parsyn-worker/.env
ExecStart=/opt/parsyn-worker/venv/bin/parsyn-worker start
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable parsyn-worker
sudo systemctl start parsyn-worker
sudo journalctl -u parsyn-worker -f

Plusieurs GPU sur une meme machine

Chaque processus worker utilise un seul GPU. Lancez plusieurs instances avec des valeurs de GPU_DEVICE differentes : 

# Terminal 1
GPU_DEVICE=cuda:0 parsyn-worker start

# Terminal 2
GPU_DEVICE=cuda:1 parsyn-worker start

Avec systemd, utilisez un template unit : 

# /etc/systemd/system/[email protected]
[Service]
EnvironmentFile=/opt/parsyn-worker/.env.%i
ExecStart=/opt/parsyn-worker/venv/bin/parsyn-worker start

# Activer par GPU
sudo systemctl enable parsyn-worker@gpu0 parsyn-worker@gpu1

Si vous utilisez l'enrollment par master key, chaque instance GPU s'enregistre comme un worker distinct et recoit sa propre API key.

Gestion de flotte

Cycle de vie des master keys

Les master keys supportent des limites et une date d'expiration :

  • max_enrollments : limite le nombre de workers pouvant s'enregistrer (null pour illimite)
  • expires_at : date d'expiration apres laquelle les nouveaux enrollments sont refuses
  • auto_name_prefix : les workers sont nommes sequentiellement (par exemple "east-worker-1", "east-worker-2")

Revoquer une master key

DELETE /api/v1/master-keys/{id}

La revocation empeche les nouveaux enrollments mais ne deconnecte pas les workers existants. Ces workers possedent deja leur propre API key individuelle.

Surveiller votre flotte

La page Workers affiche des cartes de synthese en haut (total, en ligne, en entrainement, inactifs, utilisation GPU moyenne) et un tableau en temps reel de tous les workers. Un point vert clignotant indique que la connexion WebSocket temps reel est active.

Chaque ligne du tableau affiche :

  • Statut de connexion (point vert pour inactif, rouge clignotant pour en entrainement, gris pour hors ligne)
  • Pourcentage d'utilisation GPU avec barre de progression, ainsi que la VRAM utilisee
  • Barres d'utilisation CPU et RAM
  • ID du job en cours avec barre de progression et pourcentage (si en entrainement)
  • Badge de type du worker (Both, Training only, Inference only)
  • Temps restant estime pour le job en cours

Cliquez sur une ligne pour ouvrir un panneau de details. Utilisez les icones d'action pour voir les details ou supprimer le worker.

Persistence de la cle individuelle

Lorsqu'un worker s'enregistre via une cle d'enrolement, il recoit une cle individuelle (wkr_...) que le processus worker ecrit directement dans son fichier .env sous la variable WORKER_API_KEY. Aux demarrages suivants, le worker utilise cette cle et saute l'etape d'enrolement.

Si vous devez re-enregistrer un worker (par exemple en cas de perte du .env), relancez-le en fournissant a nouveau la cle d'enrolement.

Resolution de problemes

Le worker ne peut pas se connecter

  • Verifiez l'acces reseau : curl https://parsyn.progatis.com/health
  • Verifiez que la cle d'enrolement est toujours active dans le dashboard.
  • Si vous etes derriere un pare-feu d'entreprise, assurez-vous que le trafic WebSocket (wss://) sur le port 443 est autorise.

Le worker se connecte mais se deconnecte immediatement

  • Consultez les logs du worker pour des erreurs d'authentification.
  • Verifiez le prefixe de la cle : wkr_ pour une cle individuelle, enroll_ pour les cles d'enrolement.
  • Verifiez que la cle d'enrolement n'a pas ete revoquee ou que sa limite d'enrolements n'est pas atteinte.

GPU non detecte

  • Lancez nvidia-smi pour confirmer que le GPU est visible.
  • Verifiez PyTorch : python -c "import torch; print(torch.cuda.is_available())"
  • Si vous utilisez Docker, utilisez le runtime NVIDIA : docker run --gpus all ...

Le fine-tuning plante avec une erreur OOM

  • MAX_BATCH_SIZE limite la taille de batch que le worker accepte. Reduisez-la si necessaire.
  • Activez la quantization : QUANTIZATION=4bit
  • Assurez-vous qu'aucun autre processus n'utilise le GPU.

Le telechargement du modele echoue

  • Verifiez l'acces internet vers HuggingFace : curl https://huggingface.co
  • Pour les modeles a acces restreint (Llama, Gemma, etc.), definissez HF_TOKEN avec un token ayant les droits d'acces.
  • Verifiez que CACHE_DIR dispose de suffisamment d'espace disque. Les modeles 7B necessitent au moins 15 Go.