0Pricing
AI Agents · Leçon

Agents planifiés et fondés sur Cron

APScheduler, tâches Cron et exécution autonome d’agents déclenchée par l’heure.

Agents planifiés et fondés sur Cron est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Pourquoi planifier des agents ?

Certaines tâches d’agent n’ont pas besoin de s’exécuter en continu ou à la demande : elles s’exécutent selon une planification. Les rapports quotidiens, les récapitulatifs hebdomadaires, les vérifications horaires des données et les nettoyages périodiques sont de bons candidats pour des agents planifiés.

Notions de base d’APScheduler

APScheduler (planificateur Python avancé) exécute des tâches dans votre processus Python. Il prend en charge trois types de déclencheurs : date (une seule fois), interval (répétitif) et cron (fondé sur le calendrier).

from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.schedulers.background import BackgroundScheduler
from datetime import datetime

# BlockingScheduler: takes over the main thread
# BackgroundScheduler: runs in background thread

scheduler = BackgroundScheduler()

def my_agent_job():
    print(f'Agent running at {datetime.now()}')

# Add a simple interval job
scheduler.add_job(my_agent_job, 'interval', minutes=5)

scheduler.start()
print('Scheduler started in background')

# Your app continues running here
import time
time.sleep(15)
scheduler.shutdown()
print('Scheduler stopped')

Syntaxe du déclencheur cron

Le déclencheur cron utilise des champs cron familiers : year, month, day, week, day_of_week, hour, minute, second. Vous pouvez utiliser des nombres, des plages, des listes et des caractères génériques.

from apscheduler.schedulers.background import BackgroundScheduler

scheduler = BackgroundScheduler()

def morning_briefing():
    print('Good morning! Running daily briefing agent')

def weekly_report():
    print('Running weekly summary')

def every_business_hour():
    print('Hourly check during business hours')

# Every day at 9:00 AM
scheduler.add_job(morning_briefing, 'cron', hour=9, minute=0)

# Every Monday at 8:30 AM
scheduler.add_job(weekly_report, 'cron', day_of_week='mon', hour=8, minute=30)

# Every hour from 9am to 5pm, weekdays only
scheduler.add_job(every_business_hour, 'cron',
    day_of_week='mon-fri',
    hour='9-17',
    minute=0
)

scheduler.start()
print('Jobs scheduled:', len(scheduler.get_jobs()))

Syntaxe des expressions cron

Les expressions cron standard utilisent 5 champs : minute hour day month weekday. APScheduler accepte également ces champs sous la forme d’une chaîne unique avec CronTrigger.from_crontab().

  • 0 9 * * * — tous les jours à 9 h
  • 0 9 * * 1 — tous les lundis à 9 h
  • */15 * * * * — toutes les 15 minutes
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.triggers.cron import CronTrigger

scheduler = BackgroundScheduler()

def agent_task():
    print('Running scheduled agent')

# From crontab string: every day at 9am
trigger = CronTrigger.from_crontab('0 9 * * *')
scheduler.add_job(agent_task, trigger)

# Equivalent explicit form
scheduler.add_job(
    agent_task,
    'cron',
    minute=0,
    hour=9
)

# Every 15 minutes
scheduler.add_job(agent_task, CronTrigger.from_crontab('*/15 * * * *'))

print('Scheduled jobs:')
for job in scheduler.get_jobs():
    print(f'  {job.id}: next run {job.next_run_time}')

Déclencheur à intervalle

Le déclencheur à intervalle exécute une tâche toutes les N unités de temps. Utilisez-le pour l’interrogation périodique, les signaux de présence ou toute tâche qui doit se répéter à une fréquence fixe.

from apscheduler.schedulers.background import BackgroundScheduler
from datetime import datetime, timedelta

scheduler = BackgroundScheduler()

def check_for_updates():
    print(f'Checking for updates at {datetime.now()}')
    # Agent logic: poll API, check for new items

# Every 30 minutes
scheduler.add_job(check_for_updates, 'interval', minutes=30)

# Every 2 hours, starting 10 minutes from now
start_time = datetime.now() + timedelta(minutes=10)
scheduler.add_job(
    check_for_updates,
    'interval',
    hours=2,
    start_date=start_time
)

# Run once in the future (date trigger)
from apscheduler.triggers.date import DateTrigger
run_at = datetime.now() + timedelta(minutes=5)
scheduler.add_job(check_for_updates, DateTrigger(run_date=run_at))

scheduler.start()
print('All jobs scheduled')

Paramètres et ID des tâches

Attribuez des ID aux tâches afin de pouvoir les référencer, les mettre en pause ou les supprimer ultérieurement. Transmettez des arguments à la fonction de tâche via args ou kwargs.

from apscheduler.schedulers.background import BackgroundScheduler

scheduler = BackgroundScheduler()

def fetch_report(report_type, user_id):
    print(f'Fetching {report_type} report for user {user_id}')

# Named job with arguments
scheduler.add_job(
    fetch_report,
    'cron',
    hour=9,
    minute=0,
    id='daily_report_user_42',
    kwargs={'report_type': 'daily', 'user_id': 42},
    replace_existing=True  # Update if job already exists
)

scheduler.start()

# Pause a specific job
scheduler.pause_job('daily_report_user_42')
print('Job paused')

# Resume it
scheduler.resume_job('daily_report_user_42')
print('Job resumed')

# Remove it
scheduler.remove_job('daily_report_user_42')
print('Job removed')

Conserver les tâches après les redémarrages

Par défaut, APScheduler stocke les tâches en mémoire, qui sont donc perdues lors d’un redémarrage. Utilisez un stockage de tâches SQLAlchemy pour conserver les tâches dans une base de données afin qu’elles survivent aux redémarrages.

from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
from apscheduler.executors.pool import ThreadPoolExecutor

jobstores = {
    'default': SQLAlchemyJobStore(url='sqlite:///jobs.sqlite')
}

executors = {
    'default': ThreadPoolExecutor(20)
}

scheduler = BackgroundScheduler(
    jobstores=jobstores,
    executors=executors
)

def persistent_agent():
    print('Running persisted scheduled agent')

# This job survives restarts
scheduler.add_job(
    persistent_agent,
    'cron',
    hour=8,
    minute=0,
    id='morning_agent',
    replace_existing=True
)

scheduler.start()
print('Scheduler started with SQLite persistence')

Gestion des exceptions des tâches

Entourez les fonctions de tâches planifiées d’une gestion des exceptions afin d’éviter qu’une exécution échouée n’arrête silencieusement les exécutions futures. Consignez les échecs et envoyez éventuellement des alertes.

import logging
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.events import EVENT_JOB_EXECUTED, EVENT_JOB_ERROR

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('scheduler')

scheduler = BackgroundScheduler()

def job_listener(event):
    if event.exception:
        logger.error(f'Job {event.job_id} failed: {event.exception}')
        # Optionally send alert: email, Slack, PagerDuty
    else:
        logger.info(f'Job {event.job_id} completed successfully')

scheduler.add_listener(job_listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)

def my_agent_job():
    # Errors here are caught by the listener
    raise ValueError('Something went wrong in the agent')

scheduler.add_job(my_agent_job, 'interval', seconds=10, id='test_job')
scheduler.start()

Prévenir le chevauchement des tâches

Si une tâche prend plus de temps que son intervalle, l’exécution suivante peut commencer avant la fin de la précédente. Définissez max_instances=1 (la valeur par défaut) ou utilisez le regroupement pour ignorer les exécutions manquées.

from apscheduler.schedulers.background import BackgroundScheduler
import time

scheduler = BackgroundScheduler()

def slow_agent():
    print('Agent started')
    time.sleep(45)  # Takes 45 seconds
    print('Agent finished')

# max_instances=1: only one run at a time (default)
# coalesce=True: if multiple runs were missed, fire only once when caught up
scheduler.add_job(
    slow_agent,
    'interval',
    minutes=1,
    max_instances=1,
    coalesce=True,
    id='slow_agent'
)

scheduler.start()
print('Slow agent scheduled (max 1 concurrent run)')

Intégrer la planification à FastAPI

Utilisez BackgroundScheduler d’APScheduler dans FastAPI avec le contexte lifespan pour démarrer et arrêter proprement le planificateur en fonction du cycle de vie du serveur.

from fastapi import FastAPI
from apscheduler.schedulers.background import BackgroundScheduler
from contextlib import asynccontextmanager

scheduler = BackgroundScheduler()

def morning_agent_job():
    print('Morning agent running')

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Start scheduler when app starts
    scheduler.add_job(morning_agent_job, 'cron', hour=9, minute=0)
    scheduler.start()
    print('Scheduler started')
    
    yield  # App runs here
    
    # Stop scheduler when app shuts down
    scheduler.shutdown()
    print('Scheduler stopped')

app = FastAPI(lifespan=lifespan)

@app.get('/jobs')
def list_jobs():
    return [
        {'id': job.id, 'next_run': str(job.next_run_time)}
        for job in scheduler.get_jobs()
    ]

Planification tenant compte du fuseau horaire

Précisez toujours les fuseaux horaires pour les agents planifiés. Les tâches cron dépourvues de contexte de fuseau horaire peuvent se déclencher à des heures incorrectes après les changements d’heure saisonniers.

from apscheduler.schedulers.background import BackgroundScheduler
import pytz

# Scheduler with timezone
scheduler = BackgroundScheduler(timezone='America/New_York')

def ny_morning_agent():
    print('Running at 9am New York time')

def london_eod_agent():
    print('Running at 5pm London time')

# 9am New York (handles EST/EDT automatically)
scheduler.add_job(
    ny_morning_agent,
    'cron',
    hour=9,
    minute=0,
    timezone=pytz.timezone('America/New_York')
)

# 5pm London time
scheduler.add_job(
    london_eod_agent,
    'cron',
    hour=17,
    minute=0,
    timezone=pytz.timezone('Europe/London')
)

scheduler.start()
print('Timezone-aware scheduler running')

Vérification des connaissances : planification

Vérifiez votre compréhension d’APScheduler et des agents fondés sur cron.

Bonnes pratiques de planification

Règles essentielles pour des agents planifiés fiables :

  • Utilisez toujours une planification tenant compte du fuseau horaire
  • Conservez les tâches dans une base de données afin qu’elles survivent aux redémarrages
  • Définissez max_instances=1 pour les tâches de longue durée
  • Ajoutez des écouteurs d’erreurs pour détecter les échecs silencieux
  • Consignez chaque exécution planifiée avec l’heure de début, l’heure de fin et le résultat

Questions Fréquemment Posées

La leçon « Agents planifiés et fondés sur Cron » est-elle gratuite ?

Oui — le texte complet de « Agents planifiés et fondés sur Cron » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Agents planifiés et fondés sur Cron » ?

APScheduler, tâches Cron et exécution autonome d’agents déclenchée par l’heure. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Agents planifiés et fondés sur Cron » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Schémas d’agents déclencheur-action
  2. Connecter des agents à des webhooks
  3. Agents planifiés et fondés sur Cron
  4. Construire un pipeline d’automatisation multi-applications
← Retour à AI Agents