Beat Scheduling Skill

Provides comprehensive patterns and templates for implementing periodic task scheduling with Celery Beat, including crontab, interval, and solar schedules.

Use When

• Configuring periodic/scheduled tasks in Celery applications

• Setting up cron-like schedules for recurring jobs

• Implementing interval-based task execution

• Configuring solar-based scheduling (sunrise/sunset triggers)

• Setting up django-celery-beat for database-backed schedules

• Creating dynamic schedules that can be modified at runtime

• Migrating from cron to Celery Beat

• Implementing time-zone aware scheduling

Core Capabilities

1. Crontab Schedule Configuration

Generate crontab-based schedules with precise timing control:

See templates/crontab-schedule.py for complete implementation

from celery.schedules import crontab

app.conf.beat_schedule = { 'daily-report': { 'task': 'tasks.generate_report', 'schedule': crontab(hour=0, minute=0), # Midnight daily }, 'business-hours': { 'task': 'tasks.process_orders', 'schedule': crontab(hour='9-17', minute='*/15', day_of_week='mon-fri'), } }

Key patterns:

• Daily, weekly, monthly schedules

• Business hours execution

• Complex cron expressions with multiple constraints

• Timezone-aware scheduling

2. Interval Schedule Configuration

Simple interval-based recurring tasks:

See templates/interval-schedule.py for complete implementation

from celery.schedules import schedule

app.conf.beat_schedule = { 'every-30-seconds': { 'task': 'tasks.check_status', 'schedule': 30.0, # Execute every 30 seconds }, 'every-hour': { 'task': 'tasks.cleanup', 'schedule': timedelta(hours=1), } }

Key patterns:

• Fixed interval execution

• Relative vs absolute timing

• Preventing task overlap

3. Solar Schedule Configuration

Event-based scheduling using solar calculations:

See templates/solar-schedule.py for complete implementation

from celery.schedules import solar

app.conf.beat_schedule = { 'morning-task': { 'task': 'tasks.sunrise_routine', 'schedule': solar('sunrise', 40.7128, -74.0060), # NYC coordinates } }

Supported events: sunrise, sunset, dawn_civil, dusk_astronomical, solar_noon

4. Django Celery Beat Integration

Database-backed dynamic schedules:

See templates/django-celery-beat.py for complete implementation

Schedules stored in Django database, editable via Django Admin

INSTALLED_APPS += ['django_celery_beat'] CELERY_BEAT_SCHEDULER = 'django_celery_beat.schedulers:DatabaseScheduler'

Benefits:

• Edit schedules without code changes

• Django Admin interface for schedule management

• Persistence across deployments

• Multiple scheduler instances coordination

5. Dynamic Schedule Updates

Programmatic schedule registration:

See templates/dynamic-schedules.py for complete implementation

from celery import Celery

app = Celery('tasks')

@app.on_after_configure.connect def setup_periodic_tasks(sender, **kwargs): # Add tasks programmatically sender.add_periodic_task(30.0, check_status.s(), name='status-check') sender.add_periodic_task( crontab(hour=7, minute=30), morning_report.s(), name='morning-report' )

Template Usage

Crontab Schedule Template

File: templates/crontab-schedule.py

Use for precise timing requirements:

• Daily/weekly/monthly reports

• Business hours processing

• End-of-day batch jobs

• Time-zone specific execution

Interval Schedule Template

File: templates/interval-schedule.py

Use for fixed interval tasks:

• Health checks every N seconds

• Regular cleanup jobs

• Polling external services

• Rate-limited API calls

Solar Schedule Template

File: templates/solar-schedule.py

Use for location-based timing:

• Outdoor equipment control

• Photography/lighting automation

• Energy optimization based on daylight

• Agricultural/environmental monitoring

Django Celery Beat Template

File: templates/django-celery-beat.py

Use for runtime schedule management:

• Multi-tenant applications with per-tenant schedules

• User-configurable recurring tasks

• Dynamic schedule requirements

• Administrative schedule control

Dynamic Schedules Template

File: templates/dynamic-schedules.py

Use for programmatic configuration:

• Environment-based schedule setup

• Plugin/module-based task registration

• Conditional schedule activation

• Testing and development schedules

Script Tools

validate-schedule.sh

Validates schedule configuration syntax and structure.

Usage:

bash scripts/validate-schedule.sh <config-file>

Checks:

• Valid crontab expressions

• Proper schedule type usage

• Timezone configuration

• Task name references

• Schedule conflict detection

test-beat.sh

Tests Celery Beat configuration and execution.

Usage:

bash scripts/test-beat.sh <celery-app>

Tests:

• Beat scheduler startup

• Schedule registration

• Task execution timing

• Timezone handling

Implementation Workflow

1. Choose Schedule Type

Determine the appropriate scheduling pattern:

• Crontab: Specific times (daily at 3am, weekdays at 9am)

• Interval: Fixed frequency (every 30 seconds, hourly)

• Solar: Sun-based events (sunrise, sunset)

2. Select Template

Load the appropriate template for your schedule type:

For crontab schedules

Read: templates/crontab-schedule.py

For interval schedules

Read: templates/interval-schedule.py

For Django integration

Read: templates/django-celery-beat.py

3. Configure Schedule

Customize the template with your task details:

• Task name and function reference

• Schedule expression

• Task arguments and options

• Timezone settings

4. Validate Configuration

Run validation to catch errors:

bash scripts/validate-schedule.sh celeryconfig.py

5. Test Execution

Verify schedule works as expected:

bash scripts/test-beat.sh myapp

6. Deploy Beat Scheduler

Start Celery Beat in production:

celery -A myapp beat --loglevel=info

Best Practices

Schedule Design

• Use crontab for time-of-day requirements

• Use intervals for fixed frequency needs

• Consider timezone implications for distributed systems

• Avoid overlapping executions with proper task design

Production Deployment

• Run beat scheduler as separate process (not embedded in worker)

• Use persistent schedule storage (django-celery-beat) for production

• Monitor beat scheduler health and uptime

• Implement locking for tasks that shouldn't overlap

Testing

• Test schedules with shorter intervals in development

• Verify timezone handling across environments

• Test task execution at scheduled times

• Monitor task queue depth for schedule correctness

Performance

• Limit number of scheduled tasks (beat scheduler overhead)

• Use appropriate schedule precision (avoid unnecessary frequent checks)

• Consider batch processing vs individual schedules

• Monitor beat scheduler memory and CPU usage

Common Patterns

Daily Reports

'daily-report': { 'task': 'reports.generate_daily', 'schedule': crontab(hour=0, minute=0), }

Business Hours Processing

'business-hours-sync': { 'task': 'sync.external_api', 'schedule': crontab(hour='9-17', minute='*/15', day_of_week='mon-fri'), }

Health Checks

'health-check': { 'task': 'monitoring.check_services', 'schedule': 30.0, # Every 30 seconds }

Weekend Maintenance

'weekend-cleanup': { 'task': 'maintenance.cleanup', 'schedule': crontab(hour=2, minute=0, day_of_week='sat,sun'), }

Security Compliance

This skill follows strict security rules:

• All code examples use placeholder values only

• No real API keys, passwords, or secrets

• Environment variable references in all code

• .gitignore protection documented

Troubleshooting

Schedule Not Executing

• Verify beat scheduler is running

• Check schedule syntax with validation script

• Review beat scheduler logs for errors

• Confirm task name matches actual task

Timezone Issues

• Set explicit timezone: app.conf.timezone = 'UTC'

• Use timezone-aware datetime objects

• Test schedule across timezone boundaries

• Review Celery timezone documentation

Task Overlap

• Implement task locking (Redis/database)

• Use expires option to prevent old task execution

• Monitor task execution duration

• Adjust schedule frequency if needed

Examples

See examples/ directory for detailed implementation examples:

• crontab-examples.md

• Comprehensive crontab schedule patterns

• interval-examples.md

• Interval schedule use cases

• django-celery-beat-setup.md

• Complete Django integration guide

References

• Celery Documentation: https://docs.celeryq.dev/en/stable/userguide/periodic-tasks.html

• Django Celery Beat: https://django-celery-beat.readthedocs.io/

• Crontab Reference: https://crontab.guru/

• Solar Events: https://docs.celeryq.dev/en/stable/reference/celery.schedules.html#celery.schedules.solar