分布式任务队列Celery

最新推荐文章于 2022-06-12 21:30:16 发布
最新推荐文章于 2022-06-12 21:30:16 发布
阅读量132 收藏
点赞数
文章标签： python json 数据库
原文链接：https://segmentfault.com/a/1190000006249269
版权

分布式任务队列Celery

Celery （芹菜）是基于Python开发的分布式任务队列。它支持使用任务队列的方式在分布的机器／进程／线程上执行任务调度。

结构

图片描述

核心部件

  • broker

    • 消息队列，由第三方消息中间件完成

    • 常见有RabbitMQ, Redis, MongoDB等

  • worker

    • 任务执行器

    • 可以有多个worker进程

    • worker又可以起多个queue来并行消费消息

  • backend

    • 后端存储，用于持久化任务执行结果

功能部件

  • beat

    • 定时器，用于周期性调起任务

  • flower

    • web管理界面

任务

基本用法是在程序里引用celery，并将函数方法绑定到task


from celery import Celery

app = Celery('tasks', backend='amqp', broker='amqp://guest@localhost//')
app.conf.CELERY_RESULT_BACKEND = 'db+sqlite:///results.sqlite'

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

然后调用相应方法即可(delay与apply_async都是异步调用)

from tasks import add
import time
result = add.delay(4,4)
    
while not result.ready():
  print "not ready yet"
  time.sleep(5)

print result.get()

由于是采用消息队列，因此任务提交之后，程序立刻返回一个任务ID。
之后可以通过该ID查询该任务的执行状态和结果。

关联任务

执行1个任务，完成后再执行第2个，第一个任务的结果做第二个任务的入参

add.apply_async((2, 2), link=add.s(16))
结果：2+2+16=20

还可以做错误处理

@app.task(bind=True)
def error_handler(self, uuid):
    result = self.app.AsyncResult(uuid)
    print('Task {0} raised exception: {1!r}\n{2!r}'.format(
          uuid, result.result, result.traceback))

  add.apply_async((2, 2), link_error=error_handler.s())

定时任务

让任务在指定的时间执行，与下文叙述的周期性任务是不同的。

  • ETA, 指定任务执行时间,注意时区

  • countdown, 倒计时,单位秒

from datetime import datetime, timedelta
tomorrow = datetime.utcnow() + timedelta(seconds=3)
add.apply_async((2, 2), eta=tomorrow)
result = add.apply_async((2, 2), countdown=3)
tip

  • 任务的信息是保存在broker中的，因此关闭worker并不会丢失任务信息

  • 回收任务(revoke)并非是将队列中的任务删除，而是在worker的内存中保存回收的任务task-id，不同worker之间会自动同步上述revoked task-id。

  • 由于信息是保存在内存当中的，因此如果将所有worker都关闭了，revoked task-id信息就丢失了，回收过的任务就又可以执行了。要防治这点，需要在启动worker时指定一个文件用于保存信息

celery -A app.celery worker --loglevel=info &> celery_worker.log --statedb=/var/tmp/celery_worker.state

过期时间

expires单位秒，超过过期时间还未开始执行的任务会被回收

add.apply_async((10, 10), expires=60)

重试

  • max_retries:最大重试次数

  • interval_start:重试等待时间

  • interval_step:每次重试叠加时长，假设第一重试等待1s，第二次等待1＋n秒

  • interval_max:最大等待时间

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

序列化

将任务结果按照一定格式序列化处理，支持pickle, JSON, YAML and msgpack

add.apply_async((10, 10), serializer='json')

压缩

将任务结果压缩

add.apply_async((2, 2), compression='zlib')

任务路由

使用-Q参数为队列(queue)命名，然后调用任务时可以指定相应队列

$ celery -A proj worker -l info -Q celery,priority.high    

add.apply_async(queue='priority.high')

工作流

按照一定关系一次调用多个任务

  • group: 并行调度

  • chain: 串行调度

  • chord: 类似group，但分header和body2个部分，header可以是一个group任务，执行完成后调用body的任务

  • map: 映射调度，通过输入多个入参来多次调度同一个任务

  • starmap: 类似map，入参类似＊args

  • chunks:将任务按照一定数量进行分组

group

from celery import group
>>> res = group(add.s(i, i) for i in xrange(10))()
>>> res.get(timeout=1)
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

chain

>>> from celery import chain
# 2 + 2 + 4 + 8
>>> res = chain(add.s(2, 2), add.s(4), add.s(8))()
>>> res.get()
16

可以用｜来表示chain
# ((4 + 16) * 2 + 4) * 8
>>> c2 = (add.s(4, 16) | mul.s(2) | (add.s(4) | mul.s(8)))

>>> res = c2()
>>> res.get()

chord

>>> from celery import chord
#1*2+2*2+...9*2
>>> res = chord((add.s(i, i) for i in xrange(10)), xsum.s())()
>>> res.get()
90

map

>>> from proj.tasks import add

>>> ~xsum.map([range(10), range(100)])
[45, 4950]

starmap

>>> ~add.starmap(zip(range(10), range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

chunks

>>> from proj.tasks import add

>>> res = add.chunks(zip(range(100), range(100)), 10)()
>>> res.get()
[[0, 2, 4, 6, 8, 10, 12, 14, 16, 18],
 [20, 22, 24, 26, 28, 30, 32, 34, 36, 38],
 [40, 42, 44, 46, 48, 50, 52, 54, 56, 58],
 [60, 62, 64, 66, 68, 70, 72, 74, 76, 78],
 [80, 82, 84, 86, 88, 90, 92, 94, 96, 98],
 [100, 102, 104, 106, 108, 110, 112, 114, 116, 118],
 [120, 122, 124, 126, 128, 130, 132, 134, 136, 138],
 [140, 142, 144, 146, 148, 150, 152, 154, 156, 158],
 [160, 162, 164, 166, 168, 170, 172, 174, 176, 178],
 [180, 182, 184, 186, 188, 190, 192, 194, 196, 198]]

周期性任务

周期性任务就是按照一定的时间检查反复执行的任务。前面描述的定时任务值的是一次性的任务。
程序中引入并配置好周期性任务后，beat进程就会定期调起相关任务

beat进程是需要单独启动的

$ celery -A proj beat

或者在worker启动时一起拉起

$ celery -A proj worker -B

注意一套celery只能启一个beat进程

时区配置

由于python中时间默认是utc时间，因此最简便的方法是celery也用utc时区


CELERY_TIMEZONE = 'UTC'

这么配置可以保证任务调度的时间是准确的，但由于服务器一般都配置时区，因此flower、以及日志中的时间可能会有偏差

另外一种方法，就是配置正确的时区

CELERY_TIMEZONE = 'Asia/Shanghai'

然后任务调起时，将时间带入时区配置

local_tz = pytz.timezone(app.config['CELERY_TIMEZONE'])
format_eta = local_tz.localize(datetime.strptime(eta.strip(), '%Y/%m/%d %H:%M:%S'))
add.apply_async((2, 2),eta=format_eta)

周期性任务配置

from datetime import timedelta

CELERYBEAT_SCHEDULE = {
    'add-every-30-seconds': {
        'task': 'tasks.add',
        'schedule': timedelta(seconds=30),
        'args': (16, 16)
    },
}

周期性任务配置crontab

from celery.schedules import crontab

CELERYBEAT_SCHEDULE = {
    # Executes every Monday morning at 7:30 A.M
    'add-every-monday-morning': {
        'task': 'tasks.add',
        'schedule': crontab(hour=7, minute=30, day_of_week=1),
        'args': (16, 16),
    },
}

总结

celery功能非常强大，与django、flask等web应用配合相得益彰，推荐给大家。

本文参考官方文档

weixin_34122548
关注
Celery: 分布式任务队列框架
tensory的博客
09-04 1028
Celery是一种分布式消息队列处理框架，由Python编写而成。该框架是一个典型的生产者-消费者模型。 一、一些术语与概念 下面，了解几个关键术语，并对应到生产者-消费者模型中的一些概念。 broker，存放消息队列的容器，Celery本身不提供这个容器，一般由RabbitMQ、redis等第三方消息队列机制提供。 tasks，一般写在一个脚本中，作用相当于生产者，用于产生消息。 wo...
Celery - 分布式任务队列
IT之一小佬的博客
12-29 2037
Celery - 分布式任务队列
celery——分布式任务队列服务
cwg844321258的博客
03-14 335
什么是celery？ Celery 是一个用 Python 编写的分布式的任务调度模块， Celery 是一个简单、灵活且可靠的，处理大量消息的分布式系统 它是一个专注于实时处理的任务队列，同时也支持任务调度。 任务队列是一种在线程或机器间分发任务的机制。 celery能干什么，为什么用celery呢？ celery的原理 ...
分布式队列Celery — 应用基础
without_bont的博客
01-15 413
前言 分布式任务队列 Celery，Python 后端技能树必点。结合 RabbitMQ 系列，深入梳理 Celery 知识点。当然，这也会是一个系列的文章。 简介 Celery 是一个简单、灵活且可靠的分布式任务队列（Distributed Task Queue）。队列是一种常见的数据结构，具有 FIFO（First in First Out）的特性，阻塞队列能够有效的将应
Python定时任务库Celery——分布式任务队列
XerCis的博客
04-14 4033
Celery 是一款简单灵活可靠的分布式任务执行框架，支持大量任务的并发执行。 Celery 采用典型生产者和消费者模型。生产者提交任务到任务队列，众多消费者从任务队列中取任务执行。
分布式任务队列 celery
最新发布
07-15
Celery是一个强大的分布式任务队列框架，它被广泛用于处理异步任务和分布式任务调度。它提供了基于消息传递的异步调用方式，允许你将任务分发到不同的工作者（workers）上执行。 Celery的架构包括以下几个核心组件...
Python分布式任务队列Celery深度解析
首先，Celery是一个基于分布式消息传递的作业队列，它专注于实时任务处理，同时也具备出色的调度功能。它的核心设计理念是解耦任务的创建和执行，使得任务的发起者（生产者）与执行者（消费者）之间保持松散耦合。...
分布式任务队列Celery的实践
uuqaz的博客
06-12 541
笔者写下此文总结对 Celery 的了解和在工作中的使用。本文的大概内容如下：“消息队列（Message Queue）”，后端同学应该都有了解，常见的有 RabbitMQ、RocketMQ、Kafka。而“任务队列（Task Queue）”，笔者在接触 Celery 之前是没有听过的。任务队列是什么，而任务队列和消息队列，这两者之间有何关系。带着问题，先看看 Celery 的架构：在 Celery 的架构中，可看出由多台 Server 发起异步任务（Async Task），发送任务到 Broker 的队列中
Celery——分布式任务队列
dj_pyer的博客
08-19 1182
目录 Celery概述 Celery架构 Celery应用场景 Celery特性 消息代理 Celery序列化 从一个简单的例子开始 进阶用法 Celery概述 Celery 是一个由 Python 编写的简单、灵活、可靠的用来处理大量信息的分布式系统,它同时提供操作和维护分布式系统所需的工具。 Celery 专注于实时任务处理，支持任务调度。所谓任务就是消息，消息中的有效载...
celery-分布式任务队列
小孟先森的博客
06-20 318
Celery 是一个简单的、灵活且可靠的，处理大量消息的分布式系统，并且维护这样一个系统的必要工具。 我们需要什么？ 发送者(sender)，接收者（broker） ，工作者（worker） 最简单的应用 from celery import Celery app = Celery('hello', broker="amqp://guest@localhost//") @app.ta...
celery分布式任务队列
simp的博客
03-03 286
celery分布式任务队列 Celery是基于分布式消息传递的异步任务队列/作业队列。它专注于实时操作，但也支持调度。 执行单元（称为任务）使用多处理，Eventlet或gevent在一个或多个工作服务器上并发执行。任务可以异步（在后台）或同步执行（等到准备就绪）。 Celery用于生产系统，每天处理数百万个任务。 异步实时处理 支持扩展 支持多种消息队列 使用AMQP协议 应用场景： 后台任务...
celery 实例进阶
weixin_33717117的博客
04-08 265
认识 这里有几个概念，task、worker、broker。顾名思义，task 就是老板交给你的各种任务，worker 就是你手下干活的人员。 那什么是 Broker 呢？ 老板给你下发任务时，你需要 把它记下来， 这个它 可以是你随身携带的本子，也可以是 电脑里地记事本或者excel，或者是你的 任何时间管理工具。 Broker  则是 Celery 记录task的地方。作为一个任务管理...
分布式任务队列 Celery — 应用基础
烟云的计算
01-28 2233
目录 目录 前文列表 前言 Celery 的周期定时任务 Celery 的同步调用 Celery 结果储存 Celery 的监控 Celery 的调试 前文列表 分布式任务队列 Celery 分布式任务队列 Celery —— 详解工作流 前言 紧接前文，继续看 Celery 应用基础，下列样例依旧从前文 proj 中进行修改。 Celery 的周期（定时）任务
celery --分布式任务队列
dichengpai8268的博客
10-23 345
一、介绍 celery是一个基于python开发的分布式异步消息任务队列，用于处理大量消息，同时为操作提供维护此类系统所需的工具。 它是一个任务队列，专注于实时处理，同时还支持任务调度。如果你的业务场景中需要用到异步任务，就可以考虑使用celery 二、实例场景 1、你想对100台机器执行一条批量命令，可能会花很长时间 ，但你不想让你的程序等着结果返回，而是给你返回 一个任务...
python_Celery分布式任务队列
qq_41661056的博客
04-10 394
Celery是一个简单，灵活且可靠的分布式系统，可以处理大量消息，同时为操作提供维护该系统所需的工具。 这是一个任务队列，着重于实时处理，同时还支持任务调度。 任务队列是用在线程或计算机之间分配工作的机制 Celery通过消息进行通信，通常使用代理在客户端和工作人员之间进行调解。为了启动任务，客户端将消息添加到队列中，然后代理将消息传递给工作人员 celery_test工作目录结构 (Quanti...
22.Celery 分布式任务队列
carl95271的博客
04-14 185
用户发起request，并且等待response返回。在某些视图函数处理中，可能需要执行一段耗时的程序，那么用户就会等待很长时间，造成不好的用户体验。这时候可以放到Celery分布式任务队列中去处理。 客户端：发起异步任务的一方 任务队列（broker）： 任务处理者（worker）： 保存异步处理结果（backend）： 将耗时的任务添加到队列queue中，也就是用redis实现...
分布式任务队列--Celery的学习笔记
weixin_30668887的博客
08-22 164
一、Celery简介 　　Celery是一个简单，灵活，可靠的分布式系统，用于处理大量消息，同时为操作提供维护此类系统所需的工具。它是一个任务队列，专注于实时处理，同时还支持任务调度。 　　所谓任务队列，是一个逻辑上的概念，可以将抽象中的任务发送到指定的执行任务的组件，任务队列可以跨线程或机器运行。 　　Celery是基于Python开发的分布式异步消息任务队列，通过它可以轻松的实...
Celery：分布式任务队列 简单上手
zelinhehe的专栏
10-19 1513
此文介绍 Celery 的基本用法。适合上手。 内容纲要： 0.概念。 1.选择并安装 Broker（消息传送）。 2.安装 Celery，并写一个任务。 3.运行 woker，并调用任务。 4.保存结果。 好，开始吧。 概念 Celery 是基于消息传递的异步任务队列。 它专注于实时操作,也支持调度。 执行单元,称为Task，并发执行，在一个或多个w
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值