python celery使用

简单介绍

Celery 是一个异步任务队列。一个Celery安装有三个核心组件：

1. Celery 客户端: 用于发布后台作业。当与 Flask 一起工作的时候，客户端与 Flask 应用一起运行。

2. Celery workers: 运行后台作业的进程。Celery 支持本地和远程的 workers，可以在 Flask 服务器上启动一个单独的 worker，也可以在远程服务器上启动worker，需要拷贝代码；

3. 消息代理: 客户端通过消息队列和 workers 进行通信，Celery 支持多种方式来实现这些队列。最常用的代理就是 RabbitMQ 和 Redis。

安装rabbitmq和redis

• rabbitmq安装和配置参考：http://www.cnblogs.com/cwp-bg/p/8397529.html

• redis的安装和配置参考：http://www.cnblogs.com/cwp-bg/p/8094914.html

• redis-py安装：

  sudo pip install redis

   

• redis-py操作redis参考：http://www.cnblogs.com/cwp-bg/p/8274269.html

• 为了提高性能，官方推荐使用librabbitmq，这是一个连接rabbitmq的C++的库

sudo pip install celery[librabbitmq]

初步使用

扩展

• 使用redis做结果存储，使用rabbitmq做任务队列；

  # tasks.py
  from celery import Celery
  
  app = Celery('tasks', broker='amqp://username:passwd@ip:port/varhost',backend='redis://username:passwd@ip:6390/db')
  
  @app.task
  def add(x, y):
      return x + y
  
  if __name__ == '__main__':
      result = add.delay(30, 42)

   

• broker:任务队列的中间人；

• backend:任务执行结果的存储；

• 发生了什么事

• app.task装饰后将add函数变成一个异步的任务，add.delay函数将任务序列化发送到rabbitmq；

• 记住：当有多个装饰器的时候，celery.task一定要在最外层；

• 该过程创建一个名字为celery的exchange，类型为direct（直连交换机）;创建一个名为celery的queue，队列和交换机使用路由键celery绑定；

• 打开rabbitmq管理后台，可以看到有一条消息已经在celery队列中；

• 如果使用redis作为任务队列中间人，在redis中存在两个键 celery 和 _kombu.binding.celery ， _kombu.binding.celery 表示有一名为 celery 的任务队列（Celery 默认），而 celery为默认队列中的任务列表，使用list类型，可以看看添加进去的任务数据。

• 开启worker

• 在项目目录下执行：

  celery -A app.celery_tasks.celery worker -Q queue --loglevel=info

   

• A参数指定celery对象的位置，该app.celery_tasks.celery指的是app包下面的celery_tasks.py模块的celery实例，注意一定是初始化后的实例，

• Q参数指的是该worker接收指定的队列的任务，这是为了当多个队列有不同的任务时可以独立；如果不设会接收所有的队列的任务；

• l参数指定worker的日志级别；

• 执行完毕后结果存储在redis中，查看redis中的数据，发现存在一个string类型的键值对：

  celery-task-meta-064e4262-e1ba-4e87-b4a1-52dd1418188f:data

  该键值对的失效时间为24小时。

  分析消息

• 这是添加到任务队列中的消息数据。

• {"body": "gAJ9cQAoWAQAAAB0YXNrcQFYGAAAAHRlc3RfY2VsZXJ5LmFkZF90b2dldGhlcnECWAIAAABpZHEDWCQAAAA2NmQ1YTg2Yi0xZDM5LTRjODgtYmM5OC0yYzE4YjJjOThhMjFxBFgEAAAAYXJnc3EFSwlLKoZxBlgGAAAAa3dhcmdzcQd9cQhYBwAAAHJldHJpZXNxCUsAWAMAAABldGFxCk5YBwAAAGV4cGlyZXNxC05YAwAAAHV0Y3EMiFgJAAAAY2FsbGJhY2tzcQ1OWAgAAABlcnJiYWNrc3EOTlgJAAAAdGltZWxpbWl0cQ9OToZxEFgHAAAAdGFza3NldHERTlgFAAAAY2hvcmRxEk51Lg==",   # body是序列化后使用base64编码的信息，包括具体的任务参数，其中包括了需要执行的方法、参数和一些任务基本信息
  "content-encoding": "binary", # 序列化数据的编码方式
  "content-type": "application/x-python-serialize",  # 任务数据的序列化方式，默认使用python内置的序列化模块pickle
  "headers": {}, 
  "properties": 
          {"reply_to": "b7580727-07e5-307b-b1d0-4b731a796652",       # 结果的唯一id
          "correlation_id": "66d5a86b-1d39-4c88-bc98-2c18b2c98a21",  # 任务的唯一id
          "delivery_mode": 2, 
          "delivery_info": {"priority": 0, "exchange": "celery", "routing_key": "celery"},  # 指定交换机名称，路由键，属性
          "body_encoding": "base64", # body的编码方式
          "delivery_tag": "bfcfe35d-b65b-4088-bcb5-7a1bb8c9afd9"}}

• 将序列化消息反序列化

• import pickle
  import base64
  
  result = 
  
  base64.b64decode('gAJ9cQAoWAQAAAB0YXNrcQFYGAAAAHRlc3RfY2VsZXJ5LmFkZF90b2dldGhlcnECWAIAAABpZHEDWCQAAAA2NmQ1YTg2Yi0xZDM5LTRjODgtYmM5OC0yYzE4YjJjOThhMjFxBFgEAAAAYXJnc3EFSwlLKoZxBlgGAAAAa3dhcmdzcQd9cQhYBwAAAHJldHJpZXNxCUsAWAMAAABldGFxCk5YBwAAAGV4cGlyZXNxC05YAwAAAHV0Y3EMiFgJAAAAY2FsbGJhY2tzcQ1OWAgAAABlcnJiYWNrc3EOTlgJAAAAdGltZWxpbWl0cQ9OToZxEFgHAAAAdGFza3NldHERTlgFAAAAY2hvcmRxEk51Lg==')
  print(pickle.loads(result))
  
  # 结果
  {
      'task': 'test_celery.add_together',  # 需要执行的任务
      'id': '66d5a86b-1d39-4c88-bc98-2c18b2c98a21',  # 任务的唯一id
      'args': (9, 42),   # 任务的参数
      'kwargs': {},      
      'retries': 0, 
      'eta': None, 
      'expires': None, # 任务失效时间
      'utc': True, 
      'callbacks': None, # 完成后的回调
      'errbacks': None,  # 任务失败后的回调
      'timelimit': (None, None), # 超时时间
      'taskset': None, 
      'chord': None
  }

• 常见的数据序列化方式

• binary: 二进制序列化方式；python的pickle默认的序列化方法；
  json:json 支持多种语言, 可用于跨语言方案，但好像不支持自定义的类对象；
  XML:类似标签语言；
  msgpack:二进制的类 json 序列化方案, 但比 json 的数据结构更小, 更快；
  yaml:yaml 表达能力更强, 支持的数据类型较 json 多, 但是 python 客户端的性能不如 json

• 经过比较，为了保持跨语言的兼容性和速度，采用msgpack或json方式；

• celery配置

• celery的性能和许多因素有关，比如序列化的方式，连接rabbitmq的方式，多进程、单线程等等；

• 基本配置项

  CELERY_DEFAULT_QUEUE：默认队列
  BROKER_URL  : 代理人的网址
  CELERY_RESULT_BACKEND：结果存储地址
  CELERY_TASK_SERIALIZER：任务序列化方式
  CELERY_RESULT_SERIALIZER：任务执行结果序列化方式
  CELERY_TASK_RESULT_EXPIRES：任务过期时间
  CELERY_ACCEPT_CONTENT：指定任务接受的内容序列化类型(序列化)，一个列表；

  采用配置文件的方式执行celery

  # main.py
  from celery import Celery
  import celeryconfig
  app = Celery(__name__, include=["task"])
  # 引入配置文件
  app.config_from_object(celeryconfig)
  
  if __name__ == '__main__':
      result = add.delay(30, 42)
  
  # task.py
  from main import app
  @app.task
  def add(x, y):
      return x + y  
  
  # celeryconfig.py
  BROKER_URL =  'amqp://username:password@localhost:5672/yourvhost'
  CELERY_RESULT_BACKEND = 'redis://localhost:6379/0'
  CELERY_TASK_SERIALIZER = 'msgpack'
  CELERY_RESULT_SERIALIZER = 'msgpack'
  CELERY_TASK_RESULT_EXPIRES = 60 * 60 * 24   # 任务过期时间
  CELERY_ACCEPT_CONTENT = ["msgpack"]            # 指定任务接受的内容类型.

• 一些方法

• r.ready()     # 查看任务状态，返回布尔值,  任务执行完成, 返回 True, 否则返回 False.
  r.wait()      # 等待任务完成, 返回任务执行结果，很少使用；
  r.get(timeout=1)       # 获取任务执行结果，可以设置等待时间
  r.result      # 任务执行结果.
  r.state       # PENDING, START, SUCCESS，任务当前的状态
  r.status      # PENDING, START, SUCCESS，任务当前的状态
  r.successful  # 任务成功返回true
  r.traceback  # 如果任务抛出了一个异常，你也可以获取原始的回溯信息

  celery的装饰方法celery.task

  @celery.task()
  def name():
      pass

• task()方法将任务装饰成异步，参数：

• name:可以显示指定任务的名字；

  serializer：指定序列化的方法；

  bind:一个bool值，设置是否绑定一个task的实例，如果把绑定，task实例会作为参数传递到任务方法中，可以访问task实例的所有的属性，即前面反序列化中那些属性

  @task(bind=True)  # 第一个参数是self，使用self.request访问相关的属性
  def add(self, x, y):
      logger.info(self.request.id)

  base:定义任务的基类，可以以此来定义回调函数

  import celery
  
  class MyTask(celery.Task):
      # 任务失败时执行
      def on_failure(self, exc, task_id, args, kwargs, einfo):
          print('{0!r} failed: {1!r}'.format(task_id, exc))
      # 任务成功时执行
      def on_success(self, retval, task_id, args, kwargs):
          pass
      # 任务重试时执行
      def on_retry(self, exc, task_id, args, kwargs, einfo):
          pass
  
  @task(base=MyTask)
  def add(x, y):
      raise KeyError()
  
  exc:失败时的错误的类型；
  task_id:任务的id；
  args:任务函数的参数；
  kwargs:参数；
  einfo:失败时的异常详细信息；
  retval:任务成功执行的返回值；
  

• 另外还可以指定exchange信息等，不过一般不使用；

• 调用异步任务的方法

  task.delay():这是apply_async方法的别名,但接受的参数较为简单；
  task.apply_async(args=[arg1, arg2], kwargs={key:value, key:value})
  send_task():可以发送未被注册的异步任务，即没有被celery.task装饰的任务；

  # tasks.py
  from celery import Celery
  app = Celery()
  def add(x,y):
      return x+y
  
  app.send_task('tasks.add',args=[3,4])  # 参数基本和apply_async函数一样
  # 但是send_task在发送的时候是不会检查tasks.add函数是否存在的，即使为空也会发送成功
  

• apply_async的参数：

• countdown : 设置该任务等待一段时间再执行，单位为s；

  eta : 定义任务的开始时间；eta=time.time()+10;

  expires : 设置任务时间，任务在过期时间后还没有执行则被丢弃；

  retry : 如果任务失败后, 是否重试;使用true或false，默认为true

  shadow：重新指定任务的名字str，覆盖其在日志中使用的任务名称；

  retry_policy : 重试策略.

  max_retries : 最大重试次数, 默认为 3 次.
  interval_start : 重试等待的时间间隔秒数, 默认为 0 , 表示直接重试不等待.
  interval_step : 每次重试让重试间隔增加的秒数, 可以是数字或浮点数, 默认为 0.2
  interval_max : 重试间隔最大的秒数, 即 通过 interval_step 增大到多少秒之后, 就不在增加了, 可以是数字或者浮点数, 默认为 0.2 .

  add.apply_async((2, 2), retry=True, retry_policy={
      'max_retries': 3,
      'interval_start': 0,
      'interval_step': 0.2,
      'interval_max': 0.2,
  })

  routing_key:自定义路由键；

  queue：指定发送到哪个队列；

  exchange：指定发送到哪个交换机；

  priority：任务队列的优先级，0-9之间；

  serializer：任务序列化方法；通常不设置；

  compression：压缩方案，通常有zlib, bzip2

  headers：为任务添加额外的消息；

  link：任务成功执行后的回调方法；是一个signature对象；可以用作关联任务；

  link_error: 任务失败后的回调方法，是一个signature对象；

• 自定义发布者,交换机,路由键, 队列, 优先级,序列方案和压缩方法:

• # 注意，celery4版本后，CELERY_BROKER_URL改为BROKER_URL
  BROKER_URL = 'amqp://username:passwd@host:port/虚拟主机名'
  # 指定结果的接受地址
  CELERY_RESULT_BACKEND = 'redis://username:passwd@host:port/db'
  # 指定任务序列化方式
  CELERY_TASK_SERIALIZER = 'msgpack' 
  # 指定结果序列化方式
  CELERY_RESULT_SERIALIZER = 'msgpack'
  # 任务过期时间,celery任务执行结果的超时时间
  CELERY_TASK_RESULT_EXPIRES = 60 * 20   
  # 指定任务接受的序列化类型.
  CELERY_ACCEPT_CONTENT = ["msgpack"]   
  # 任务发送完成是否需要确认，这一项对性能有一点影响     
  CELERY_ACKS_LATE = True  
  # 压缩方案选择，可以是zlib, bzip2，默认是发送没有压缩的数据
  CELERY_MESSAGE_COMPRESSION = 'zlib' 
  # 规定完成任务的时间
  CELERYD_TASK_TIME_LIMIT = 5  # 在5s内完成任务，否则执行该任务的worker将被杀死，任务移交给父进程
  # celery worker的并发数，默认是服务器的内核数目,也是命令行-c参数指定的数目
  CELERYD_CONCURRENCY = 4 
  # celery worker 每次去rabbitmq预取任务的数量
  CELERYD_PREFETCH_MULTIPLIER = 4 
  # 每个worker执行了多少任务就会死掉，默认是无限的
  CELERYD_MAX_TASKS_PER_CHILD = 40 
  # 设置默认的队列名称，如果一个消息不符合其他的队列就会放在默认队列里面，如果什么都不设置的话，数据都会发送到默认的队列中
  CELERY_DEFAULT_QUEUE = "default" 
  # 设置详细的队列
  CELERY_QUEUES = {
      "default": { # 这是上面指定的默认队列
          "exchange": "default",
          "exchange_type": "direct",
          "routing_key": "default"
      },
      "topicqueue": { # 这是一个topic队列 凡是topictest开头的routing key都会被放到这个队列
          "routing_key": "topic.#",
          "exchange": "topic_exchange",
          "exchange_type": "topic",
      },
      "task_eeg": { # 设置扇形交换机
          "exchange": "tasks",
          "exchange_type": "fanout",
          "binding_key": "tasks",
      },
      
  }
  

  -参考：

• http://docs.celeryproject.org/en/latest/userguide/tasks.html#task-options

• http://docs.jinkan.org/docs/flask/patterns/celery.html

• http://www.pythondoc.com/flask-celery/first.html

• https://blog.csdn.net/kk123a/article/details/74549117

• https://blog.csdn.net/preyta/article/details/54288870

• task.apply_async((2,2), 
      compression='zlib',
      serialize='json',
      queue='priority.high',
      routing_key='web.add',
      priority=0,
      exchange='web_exchange')

  一份比较常用的配置文件

   

# 注意，celery4版本后，CELERY_BROKER_URL改为BROKER_URL
BROKER_URL = 'amqp://username:passwd@host:port/虚拟主机名'
# 指定结果的接受地址
CELERY_RESULT_BACKEND = 'redis://username:passwd@host:port/db'
# 指定任务序列化方式
CELERY_TASK_SERIALIZER = 'msgpack' 
# 指定结果序列化方式
CELERY_RESULT_SERIALIZER = 'msgpack'
# 任务过期时间,celery任务执行结果的超时时间
CELERY_TASK_RESULT_EXPIRES = 60 * 20   
# 指定任务接受的序列化类型.
CELERY_ACCEPT_CONTENT = ["msgpack"]   
# 任务发送完成是否需要确认，这一项对性能有一点影响     
CELERY_ACKS_LATE = True  
# 压缩方案选择，可以是zlib, bzip2，默认是发送没有压缩的数据
CELERY_MESSAGE_COMPRESSION = 'zlib' 
# 规定完成任务的时间
CELERYD_TASK_TIME_LIMIT = 5  # 在5s内完成任务，否则执行该任务的worker将被杀死，任务移交给父进程
# celery worker的并发数，默认是服务器的内核数目,也是命令行-c参数指定的数目
CELERYD_CONCURRENCY = 4 
# celery worker 每次去rabbitmq预取任务的数量
CELERYD_PREFETCH_MULTIPLIER = 4 
# 每个worker执行了多少任务就会死掉，默认是无限的
CELERYD_MAX_TASKS_PER_CHILD = 40 
# 设置默认的队列名称，如果一个消息不符合其他的队列就会放在默认队列里面，如果什么都不设置的话，数据都会发送到默认的队列中
CELERY_DEFAULT_QUEUE = "default" 
# 设置详细的队列
CELERY_QUEUES = {
    "default": { # 这是上面指定的默认队列
        "exchange": "default",
        "exchange_type": "direct",
        "routing_key": "default"
    },
    "topicqueue": { # 这是一个topic队列 凡是topictest开头的routing key都会被放到这个队列
        "routing_key": "topic.#",
        "exchange": "topic_exchange",
        "exchange_type": "topic",
    },
    "task_eeg": { # 设置扇形交换机
        "exchange": "tasks",
        "exchange_type": "fanout",
        "binding_key": "tasks",
    },
    
}