分布式任务队列celery用法详解

celery基础介绍：

这个图我们可以看出，celery基本结构也就是四部分
1 第一部分 生产者发布任务，也就是我们针对每一个task任务进行实际的调用
2 第二部分 broker也就是中间件消息队列，作用就是用来接收生产者的请求
这一部分常见玩法可以是rabbitmq和redis等
3 第三部分 worker 也就是工作队列 也就是celery本身的任务队列服务，一般情况下大型的生产应用我们会结合supervisor来管理这么多的worker
4 第四部分 result 存储，就是把执行的结果，状态等信息进行存储，常规用法我们可以用rabbitmq redis，mysql，mongodb等来做
环境部署：
1pip install celery
2 安装 rabbitmq 这个我得博客有篇文章做了详细讲解
3 安装redis ，源码安装很简单，不做介绍

首先做一个基础的例子体验什么是celery
[root@localhost www]# cat tasks.py
#!/usr/bin/python
#coding:utf-8
from celery import Celery
app = Celery('tasks', broker='amqp://',backend='redis://')
#app.config_from_object('celeryconfig')

@app.task
def add(x, y):
return x + y
broker是接受的消息队列的地址我这里用的rabbitmq的地址
backend是后端的存储我这里用的是redis

启动task
celery -A tasks worker --loglevel=info
然后我们新开一个终端进入python命令行去调用task
#python
#from tasks import add
#add.delay(2,4)

可以看出我们每次在python终端调用add这个任务 celery的worker 信息里面就会收到操作并记录信息 同时redis里面记录相应的状态

======================================================

celery与tasks分离

[root@localhost test]# cat celery.py
#!/usr/bin/python
#coding:utf-8

from future import absolute_import ,unicode_literals
from celery import Celery

app = Celery(
'test',
broker='amqp://',
backend='redis://',
include=['test.tasks']
)

app.conf.update(
result_expires=3500,
)

if name == 'main':
app.start()

[root@localhost test]# cat tasks.py
#!/usr/bin/python
#coding:utf-8

from future import absolute_import ,unicode_literals

from test.celery import app

@app.task
def add(x,y):
return x + ybr/>@app.task
def cheng(x,y):
return x * y

后台启动 celery
celery multi start w1 -A proj -l info --logfile=/var/log/celery.log

大型线上项目都会使用专门的配置分离文件来控制task
如下
目录结构

专门的配置文件
[root@localhost celery]# cat celeryconfig.py
#!/usr/bin/python
#coding:utf-8

from kombu import Exchange, Queue
BROKER_URL = 'amqp://localhost'# 消息存储数据存储rabbitmq
CELERY_RESULT_BACKEND = 'redis://localhost/0'# 消息执行后的结果包括函数返回值的数据存储在仓库0
CELERY_QUEUES = (# 定义任务队列
Queue("default", Exchange("default"), routing_key="default"),
Queue("for_task_realtime", Exchange("for_task_realtime"), routing_key="task_realtime"),
Queue("for_task_timer", Exchange("for_task_timer"), routing_key="task_timer"),
Queue("for_task_monitor", Exchange("for_task_monitor"), routing_key="task_monitor")
)

CELERY_ROUTES = {# 定义routes用来决定不同的任务去哪一个queue

'tasks.taskrealtime': {"queue": "for_task_realtime", "routing_key": "task_realtime"},

'tasks.tasktimer': {"queue": "for_task_timer", "routing_key": "task_timer"},

'tasks.taskmonitor': {"queue": "for_task_monitor", "routing_key": "task_monitor"},
}

实际的task任务代码
[root@localhost celery]# cat tasks.py
#!/usr/bin/python

from celery import Celery
import subprocess

app = Celery()
app.config_from_object("celeryconfig")

@app.task
def taskrealtime(x, y):
return x + y, 'taskrealtime'

@app.task
def tasktimer(x, y):
return x + y, 'tasktimer'

@app.task
def taskmonitor(x, y):
return x + y, 'taskmonitor'
从这里我们 可以看出来，我们只需要用内置方法去引用配置就可以了

发布任务文件：

[root@localhost celery]# cat testcelery.py
#!/usr/bin/python

from tasks import *

r = taskrealtime.delay(1, 1)
print r,r.get()

r = tasktimer.delay(2, 2)
print r,r.get()

r = taskmonitor.delay(3, 3)
print r,r.get()
启动celery
celery -A tasks worker -c 4 --loglevel=info
info信息如下

我们可以看出每一个任务都进入了指定的队列，在配置文件定义的队列

发布任务执行输出如图

redis后端存储如图

=======================================================
celery的进程不是后台启动的，当有很多的进程的时候我们 需要一个专业的工具来进行celery进程的管理这里介绍supervisor
supervisor是python写的一个进程管理工具
安装supervisor
pip install supervisor
生成supervisor配置文件
echo_supervidord_conf > /etc/supervisord.conf

vi /etc/supervisord.conf
配置介绍
主要是进程管理模块其他基本不动

所以直接在配置文件最后面添加一段进程管理的配置就可以了

[program:celery]
command=/usr/bin/celery worker -A tasks
directory=/data/www
stdout_logfile=/data/logs/celery.log
autostart=true
autorestart=true
redirect_stderr=true
stopsignal=QUIT

启动supervisor
/usr/bin/supervisord
这个时候已经启动了管理的进程celery
我们可以查看管理的进程的状态
supervisorctl status celery
重启 管理的进程
supervisorctl restart celery
启动管理的进程
supervisorctl start celery
停止管理的进程
supervisorctl stop celery

====================================================

celery有一堆的配置参数来控制每一个task这里不做解说详情见官网

重点是思路：
1 以前批量执行paramiko脚本的时候，一旦执行的机器多了，后来优化成多线程用threading来做，看到这个异步的任务队列，我们可以把机器按队列进行分组，进行路由限制数量，流量控制等等来对大批量的task任务进行分批量并发操作
2 还可以结合python框架web界面 applicate的过程，celery的worker的过程状态和后端的结果状态都集成到一个页面，实时监测，界面化操作

转载于:https://blog.51cto.com/13945009/2170428