Planification, exécution et gestion des jobs
Planification, exécution et gestion des jobs
Comprendre le scheduler, la file d'exécution et comment piloter vos hooks programmés
Fonctionnement du scheduler : comment les exécutions sont planifiées, mises en file et exécutées — et comment annuler proprement les jobs d’un projet.
Ce que couvre cette page
Planification prédictive
Comment définir les fréquences (pair count + duration) et comprendre la date de prochaine exécution calculée côté serveur.
Exécution en file
Que se passe-t-il quand une exécution est due : mise en file, prise en charge par les workers et suivi d’état.
Annulation et contrôle
Comment annuler les jobs d’un projet, que font les annulations sur les jobs en attente vs actifs, et recommandations.
Surveillance & reprise
Suivre le statut en temps réel, gérer les erreurs et relancer ou désactiver des hooks.
Consommation & coûts
Rappel : les exécutions via des agents peuvent consommer des crédits — vérifier avant de lancer des traitements massifs.
Bonnes pratiques
Conseils pour éviter les doublons, gérer les horaires et limiter l’impact sur le quota de votre projet.
Courte introduction Cette page explique, côté utilisateur, comment planifier des hooks, comment le système calcule la prochaine exécution, comment les exécutions sont mises en file et traitées, et comment annuler les jobs d’un projet. Vous y trouverez des procédures pas à pas, des scénarios types, des astuces pour éviter les erreurs courantes et des réponses aux questions fréquentes.
Workflow : Créer et planifier un hook (pas à pas)
Étape 1 — Ouvrir la gestion des hooks du projet
Depuis la page de votre projet, allez dans l’onglet Agents / Hooks (ou l’équivalent “Hooks d’automatisation”). Ouvrez le dialogue de création/modification d’un hook.
Étape 2 — Choisir l’agent et le trigger
Sélectionnez l’agent (workflow) que vous souhaitez exécuter régulièrement et précisez la source de déclenchement (p.ex. commit, branche, ou planification).
Étape 3 — Définir la fréquence (pair count + duration)
Renseignez les deux valeurs : frequency_count (un entier) et frequency_duration (unité : day, week, month, year…). Exemples :
- 1 + day → exécution quotidienne.
- 2 + week → toutes les 2 semaines.
- 1 + month → tous les mois. Ces deux champs forment la règle qui déterminera la prochaine date d’exécution.
Étape 4 — Vérifier l’aperçu de la prochaine exécution
Avant d’enregistrer, utilisez la prévisualisation de la date (si présente) ou vérifiez l’heure serveur affichée pour comprendre quand la première exécution sera due. Si l’interface propose un champ “server time”, comparez-le à votre fuseau horaire.
Étape 5 — Enregistrer et activer
Enregistrez le hook. Tant que le hook existe et reste activé, le système calculera la prochaine exécution et l’enregistrera côté serveur.
Étape 6 — Tester le comportement (optionnel)
Si vous voulez tester immédiatement : lancez un exécution manuelle (bouton “Run now” / “Exécuter maintenant” si disponible) ou simulez l’événement attendu (p.ex. traiter des commits récents). Surveillez les résultats et les logs dans la page du projet.
Étape 7 — Modifier ou désactiver
Pour arrêter les exécutions planifiées, désactivez ou supprimez le hook dans la gestion des hooks. Modifier la fréquence mettra à jour la prochaine date calculée.
Astuce — Commencez par un intervalle conservateur
Pour les nouveaux hooks, commencez par une fréquence peu fréquente (p.ex. hebdomadaire) pour vérifier l’output, éviter une consommation excessive de crédits et ajuster les filtres avant d’augmenter la cadence.
Workflow : Comment le système calcule la prochaine exécution (explications utilisateur)
Étape 1 — La règle est la source de vérité
La prochaine exécution est déterminée à partir des deux valeurs que vous avez fournies : un compte (count) et une durée (day/week/month/year). Le calcul est réalisé côté serveur à chaque exécution ou modification du hook.
Étape 2 — Cas simple : add count × duration
Si la règle est (1, day) et la dernière exécution a eu lieu aujourd’hui à 10:00, la prochaine sera programmée demain à 10:00 (serveur). Même logique pour week/month/year : on ajoute count × unité.
Étape 3 — Cas particuliers temporels
Pour les durées mensuelles ou annuelles, la règle conserve le jour du mois quand c’est possible ; si une date n’existe pas (ex : 31 février), la logique règle la prochaine date sur le dernier jour valide du mois cible.
Étape 4 — Absence de fréquence
Si une des deux valeurs est vide ou nulle, aucune date future n’est calculée : le hook n’est pas programmé automatiquement.
Étape 5 — Synchronisation heure serveur / client
L’horodatage de référence est l’heure serveur. Consultez l’horloge serveur dans le dialogue de hook si disponible pour éviter les surprises liées au fuseau horaire.
Utilisation typique : résumés journaliers, veille automatique. Avantages : résultats récents. Risques : consommation de crédits si l’agent est coûteux. Recommandation : activer des filtres pour réduire le volume à traiter.
Avant : exécution manuelle unique
- Vous lancez l’agent quand vous voulez.
- Permet vérification rapide.
- Idéal pour tests.
Après : planification régulière
- Automatisation sans intervention.
- Garde le projet à jour.
- Nécessite vigilance sur le volume et les crédits.
Astuce — Utilisez la prévisualisation des filtres
Avant d’activer une planification fréquente, utilisez la prévisualisation (preview) pour voir quels inputs seraient traités. Cela évite des exécutions inutiles et limite la consommation.
Workflow : Exécution et file d’attente — que surveiller et comment agir
Étape 1 — Quand une exécution devient due
Au moment où la date programmée arrive, le système met l’exécution dans la file d’attente. L’entrée contient les paramètres et l’input déterminés par le hook.
Étape 2 — Mise en file (visible depuis l’interface)
Les exécutions en attente peuvent apparaître dans la section de progression du projet (liste des jobs en cours). Une indication “pending” ou “queued” est souvent visible avant que le traitement commence réellement.
Étape 3 — Les workers prennent les jobs
Des workers prennent les jobs en file, traitent l’agent (les étapes définies) et transmettent le statut en temps réel. Vous verrez des mises à jour de progression et des logs / messages de sortie.
Étape 4 — Monitoring et logs
Sur la page du projet, suivez la progression, les messages et les documents générés. Les mises à jour en temps réel facilitent le repérage d’erreurs ou de comportements inattendus.
Étape 5 — Résilience et retries
En cas d’erreur, certains jobs peuvent être réessayés automatiquement ou marqués comme échoués — surveillez les notifications et corrigez les filtres/inputs avant de relancer.
Étape 6 — Fin de job et mise à jour de la prochaine exécution
Après une exécution réussie, la date de dernière exécution est mise à jour et le système calcule une nouvelle prochaine date en ajoutant (count × duration) à la date courante.
Attention — Consommation de crédits et sorties partielles
Une exécution lancée par un hook peut consommer des crédits selon l’agent utilisé. Si vous annulez en cours d’exécution, des crédits peuvent déjà avoir été consommés et certains résultats intermédiaires peuvent avoir été générés. Prévoyez un budget ou un mode test avant les exécutions massives.
Workflow : Annuler des jobs en cours sur un projet (procédure utilisateur)
Étape 1 — Localiser la commande d’annulation
Sur la page principale du projet, trouvez l’action dédiée (souvent affichée “Cancel jobs”, “Annuler jobs” ou bouton similaire) dans la section de progression / gestion des jobs.
Étape 2 — Lancer l’annulation
Cliquez sur “Annuler jobs”. Le système traitera les jobs en attente et signera l’intention d’annulation pour les jobs actuellement actifs.
Étape 3 — Résultats attendus immédiatement
- Les jobs en attente (queued / delayed) sont retirés de la file et ne seront pas exécutés.
- Les jobs actifs sont marqués comme annulés : ils ne sont pas toujours stoppés instantanément, mais les workers sont informés et doivent cesser le traitement dès qu’il est sûr de le faire.
Étape 4 — Nettoyage et UI
Après l’annulation, l’interface du projet doit refléter l’arrêt : barres de progression nettoyées, messages, et éventuellement suppression des compteurs de job. Si vous avez un suivi local (localStorage ou affichage temporaire), il peut être effacé automatiquement ou via un rafraîchissement.
Étape 5 — Que faire si l’annulation ne s’applique pas complètement
Si un job continue à progresser quelques instants après l’annulation, attendez la fin du cycle sûr du worker (quelques secondes à minutes selon la taille du job). En cas de persistance, contactez l’administrateur ou relancez un nettoyage / nouvel envoi des sources.
Étape 6 — Relancer ou reprogrammer
Pour relancer un traitement annulé, ré-enfilez manuellement les sources ou ajustez/dupliquez le hook puis activez-le. Si vous aviez supprimé le hook, recréez-le et définissez la fréquence désirée.
Tip — Annuler avant d’effacer les sources
Si vous prévoyez de supprimer un projet ou d’enlever de grosses sources, annulez d’abord les jobs en cours. Cela réduit les risques d’exécutions partielles et d’utilisation inutile de crédits.
Tip — Vérifier l’horloge serveur pour les premiers runs
Si vous planifiez des exécutions proches dans le temps (p.ex. la première exécution dans l’heure), comparez votre heure locale et l’heure serveur. Une différence de fuseau horaire ou un décalage peut décaler la première exécution d’une date.
Pièges fréquents et limites à connaître
- Modifier la fréquence d’un hook après qu’une exécution a été programmée n’annule pas l’exécution déjà enfermée dans la file : la prochaine date sera recalculée à la fin du cycle.
- Les jobs actifs ne sont pas toujours interrompus instantanément ; ils peuvent produire des résultats partiels.
- Les exécutions automatisées peuvent générer des sorties externes (webhooks, emails) dès qu’un step produit un résultat : vérifiez vos destinations avant d’activer.
Frequently Asked Questions
Prêt à gérer vos hooks programmés ?
Consultez la page de votre projet pour créer, tester ou annuler des hooks. Commencez par une exécution manuelle pour valider la sortie avant d’activer une planification fréquente.