0
# Management Commands
1

2
Django management commands for worker control, queue monitoring, and system maintenance. These commands integrate RQ functionality with Django's management system.
3

4
## Capabilities
5

6
### Worker Management
7

8
Commands for starting and managing RQ workers.
9

10
#### rqworker
11

12
Start RQ workers to process jobs from specified queues.
13

14
```bash
15
# Basic usage
16
python manage.py rqworker [queue_names...]
17

18
# Process default queue
19
python manage.py rqworker
20

21
# Process multiple queues with priority
22
python manage.py rqworker high default low
23

24
# Worker options
25
python manage.py rqworker --burst                    # Exit after processing all jobs
26
python manage.py rqworker --worker-class path.to.Worker  # Custom worker class
27
python manage.py rqworker --queue-class path.to.Queue    # Custom queue class
28
python manage.py rqworker --job-class path.to.Job        # Custom job class
29
python manage.py rqworker --sentry-dsn=DSN_URL          # Sentry integration
30
```
31

32
#### rqworker-pool
33

34
Start RQ worker pool with multiple processes (RQ 2.10+).
35

36
```bash
37
# Start worker pool
38
python manage.py rqworker-pool [queue_names...] --num-workers 4
39

40
# Pool options
41
python manage.py rqworker-pool default low --num-workers 8
42
python manage.py rqworker-pool --queue-class path.to.Queue
43
python manage.py rqworker-pool --job-class path.to.Job
44
```
45

46
### Scheduler Management
47

48
Commands for managing job scheduling.
49

50
#### rqscheduler
51

52
Start RQ scheduler daemon for processing scheduled jobs.
53

54
```bash
55
# Start scheduler
56
python manage.py rqscheduler
57

58
# Scheduler options
59
python manage.py rqscheduler --interval=30    # Custom polling interval
60
python manage.py rqscheduler --queue=high     # Specific queue
61
```
62

63
### Queue Monitoring
64

65
Commands for monitoring queue status and statistics.
66

67
#### rqstats
68

69
Display real-time queue statistics and monitoring information.
70

71
```bash
72
# Show statistics once
73
python manage.py rqstats
74

75
# Continuous monitoring
76
python manage.py rqstats --interval=1    # Refresh every second
77

78
# Output formats
79
python manage.py rqstats --json          # JSON output
80
python manage.py rqstats --yaml          # YAML output
81
```
82

83
Statistics include:
84
- Queue lengths and job counts
85
- Worker status and counts
86
- Job processing rates
87
- Failed job counts
88
- Memory usage information
89

90
### Queue Control
91

92
Commands for controlling queue behavior and job processing.
93

94
#### rqsuspend
95

96
Suspend workers from picking up new jobs.
97

98
```bash
99
# Suspend indefinitely
100
python manage.py rqsuspend
101

102
# Suspend for specific duration (in seconds)
103
python manage.py rqsuspend -d 600        # Suspend for 10 minutes
104
python manage.py rqsuspend --duration=3600  # Suspend for 1 hour
105
```
106

107
#### rqresume
108

109
Resume suspended workers to continue processing jobs.
110

111
```bash
112
# Resume all suspended workers
113
python manage.py rqresume
114
```
115

116
### Job Enqueueing
117

118
Commands for enqueueing jobs from the command line.
119

120
#### rqenqueue
121

122
Enqueue a job directly from the command line.
123

124
```bash
125
# Enqueue function
126
python manage.py rqenqueue myapp.tasks.my_function arg1 arg2
127

128
# With options
129
python manage.py rqenqueue myapp.tasks.my_function --queue=high
130
python manage.py rqenqueue myapp.tasks.my_function --timeout=3600
131
```
132

133
## Command Implementation Details
134

135
### Worker Command Options
136

137
```python { .api }
138
# rqworker command options
139
class Command:
140
    """
141
    Django management command for starting RQ workers.
142
    
143
    Options:
144
        queue_names: Queues to process (default: 'default')
145
        --burst: Exit after processing all current jobs
146
        --worker-class: Custom worker class path
147
        --queue-class: Custom queue class path  
148
        --job-class: Custom job class path
149
        --sentry-dsn: Sentry DSN for error tracking
150
        --sentry-debug: Enable Sentry debug mode
151
        --sentry-ca-certs: Path to CA certificates
152
    """
153
```
154

155
### Scheduler Command Options
156

157
```python { .api }
158
# rqscheduler command options
159
class Command:
160
    """
161
    Django management command for starting RQ scheduler.
162
    
163
    Options:
164
        --interval: Polling interval in seconds (default: 60)
165
        --queue: Queue name to use (default: 'default')
166
    """
167
```
168

169
### Stats Command Options
170

171
```python { .api }
172
# rqstats command options  
173
class Command:
174
    """
175
    Django management command for displaying queue statistics.
176
    
177
    Options:
178
        --interval: Refresh interval for continuous monitoring
179
        --json: Output statistics in JSON format
180
        --yaml: Output statistics in YAML format
181
    """
182
```
183

184
## Production Usage Patterns
185

186
### Systemd Service Configuration
187

188
Example systemd service for running RQ workers:
189

190
```ini
191
[Unit]
192
Description=Django-RQ Worker
193
After=network.target
194

195
[Service]
196
Type=simple
197
User=www-data
198
WorkingDirectory=/path/to/project
199
Environment=DJANGO_SETTINGS_MODULE=myproject.settings
200
ExecStart=/path/to/venv/bin/python manage.py rqworker high default low
201
Restart=always
202
RestartSec=3
203

204
[Install]
205
WantedBy=multi-user.target
206
```
207

208
### Docker Configuration
209

210
Example Docker setup for RQ workers:
211

212
```dockerfile
213
# Worker container
214
FROM python:3.11
215
COPY . /app
216
WORKDIR /app
217
RUN pip install -r requirements.txt
218
CMD ["python", "manage.py", "rqworker", "high", "default", "low"]
219
```
220

221
### Process Management
222

223
Best practices for production deployment:
224

225
```bash
226
# Multiple worker processes
227
python manage.py rqworker high &
228
python manage.py rqworker default &
229
python manage.py rqworker low &
230

231
# Worker pool for high throughput
232
python manage.py rqworker-pool default --num-workers 8 &
233

234
# Scheduler process
235
python manage.py rqscheduler &
236

237
# Monitoring process
238
python manage.py rqstats --interval=60 --json > /var/log/rq-stats.log &
239
```
240

241
## Command Integration
242

243
### Settings Integration
244

245
Commands respect Django settings configuration:
246

247
```python
248
# settings.py
249
RQ_QUEUES = {
250
    'high': {'HOST': 'redis-high', 'PORT': 6379, 'DB': 0},
251
    'default': {'HOST': 'redis-default', 'PORT': 6379, 'DB': 0},
252
    'low': {'HOST': 'redis-low', 'PORT': 6379, 'DB': 0},
253
}
254

255
RQ = {
256
    'WORKER_CLASS': 'myapp.workers.CustomWorker',
257
    'JOB_CLASS': 'myapp.jobs.CustomJob',
258
    'DEFAULT_RESULT_TTL': 500,
259
}
260
```
261

262
### Logging Integration
263

264
Commands integrate with Django's logging system:
265

266
```python
267
# settings.py
268
LOGGING = {
269
    'version': 1,
270
    'handlers': {
271
        'rq_console': {
272
            'level': 'DEBUG',
273
            'class': 'rq.logutils.ColorizingStreamHandler',
274
        },
275
    },
276
    'loggers': {
277
        'rq.worker': {
278
            'handlers': ['rq_console'],
279
            'level': 'DEBUG'
280
        },
281
    }
282
}
283
```
284

285
### Signal Handling
286

287
Commands handle system signals gracefully:
288

289
- `SIGTERM`: Graceful shutdown after current job completion
290
- `SIGINT`: Immediate shutdown (Ctrl+C)
291
- `SIGUSR1`: Force job failure and continue
292
- `SIGUSR2`: Suspend/resume worker
293

294
## Monitoring and Debugging
295

296
### Health Checks
297

298
Monitor worker and scheduler health:
299

300
```bash
301
# Check worker status
302
python manage.py rqstats --json | jq '.queues[].workers'
303

304
# Check scheduler status  
305
python manage.py rqstats --json | jq '.schedulers'
306

307
# Monitor job processing rates
308
python manage.py rqstats --interval=5
309
```
310

311
### Troubleshooting
312

313
Common issues and solutions:
314

315
1. **Workers not starting**: Check Redis connectivity and queue configuration
316
2. **Jobs not processing**: Verify worker is listening to correct queues
317
3. **Memory issues**: Monitor worker memory usage, consider worker recycling
318
4. **Failed jobs**: Check failed job registry and error logs
319
5. **Scheduler not working**: Ensure rq-scheduler is installed and running