Celery 异步分布式 171219

最新推荐文章于 2024-09-06 15:03:41 发布
最新推荐文章于 2024-09-06 15:03:41 发布
阅读量932 收藏 2
点赞数
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanyangjie/article/details/78840897
版权

celery是Python开发的分布式异步任务调度系统，Celery支持的消息服务有rmq、redis等 

Celery 是一个强大的分布式任务队列，它可以让任务的执行完全脱离主程序，甚至可以被分配到其他主机上运行。我们通常使用它来实现异步任务（async task）和定时任务（crontab）。它的架构组成如下图：


celery由5个主要组件组成: 
producer: 任务发布者, 通过调用API向celery发布任务的程序 
celery beat: 任务调度, 根据配置文件发布定时任务 
worker: 实际执行任务的程序 
broker: 接受任务消息,存入队列再按顺序分发给worker执行 
backend: 存储结果的服务器

Celery 主要包含以下几个模块：

  • 任务模块
    包含异步任务和定时任务。其中，异步任务通常在业务逻辑中被触发并发往任务队列，而定时任务由 Celery Beat 进程周期性地将任务发往任务队列。

  • 消息中间件 Broker
    Broker，即为任务调度队列，接收任务生产者发来的消息（即任务），将任务存入队列。Celery 本身不提供队列服务，官方推荐使用 RabbitMQ 和 Redis 等。

  • 任务执行单元 Worker
    Worker 是执行任务的处理单元，它实时监控消息队列，获取队列中调度的任务，并执行它。

  • 任务结果存储 Backend
    Backend 用于存储任务的执行结果，以供查询。同消息中间件一样，存储也可使用 RabbitMQ, Redis 和 MongoDB 等。

异步任务：

使用 Celery 实现异步任务主要包含三个步骤：

  1. 创建一个 Celery 实例

  2. 启动 Celery Worker

  3. 应用程序调用异步任务

在运行下面的例子之前，请确保 redis 已正确安装，并开启 redis 服务，当然，celery 也是要安装的。可以使用下面的命令来安装 celery 及相关依赖： 

$ pip install 'celery[redis]'
# -*- coding: utf-8 -*-

import time
from celery import Celery

broker = 'redis://127.0.0.1:6379'
backend = 'redis://127.0.0.1:6379/0'

app = Celery('my_task', broker=broker, backend=backend)

@app.task
def add(x, y):
    time.sleep(5)     # 模拟耗时操作
    return x + y

将上面的代码保存为文件 tasks.py，做了几件事：

  • 创建了一个 Celery 实例 app，名称为 my_task；

  • 指定消息中间件用 redis，URL 为 redis://127.0.0.1:6379；

  • 指定存储用 redis，URL 为 redis://127.0.0.1:6379/0；

  • 创建了一个 Celery 任务 add，当函数被 @app.task 装饰后，就成为可被 Celery 调度的任务；

启动 Celery Worker

在当前目录，使用如下方式启动 Celery Worker：

$ celery worker -A tasks --loglevel=info

其中：

  • 参数 -A 指定了 Celery 实例的位置，本例是在 tasks.py 中，Celery 会自动在该文件中寻找 Celery 对象实例，当然，我们也可以自己指定，在本例，使用 -A tasks.app；

  • 参数 --loglevel 指定了日志级别，默认为 warning，也可以使用 -l info 来表示；

在生产环境中，我们通常会使用 Supervisor 来控制 Celery Worker 进程。

调用任务

现在，我们可以在应用程序中使用 delay() 或 apply_async() 方法来调用任务。

在当前目录打开 Python 控制台，输入以下代码：

>>> from tasks import add
>>> add.delay(2, 8)
<AsyncResult: 2272ddce-8be5-493f-b5ff-35a0d9fe600f>
我们从  tasks.py  文件中导入了  add  任务对象，然后使用  delay()  方法将任务发送到消息中间件（Broker），Celery Worker 进程监控到该任务后，就会进行执行。我们将窗口切换到 Worker 的启动窗口，会看到多了两条日志 

INFO/MainProcess] Received task: tasks.add[2272ddce-8be5-493f-b5ff-35a0d9fe600f]
 INFO/PoolWorker-4] Task tasks.add[2272ddce-8be5-493f-b5ff-35a0d9fe600f] succeeded in 5.00642602402s: 10

这说明任务已经被调度并执行成功。

另外，我们如果想获取执行后的结果，可以这样做：

>>> result = add.delay(2, 6)
>>> result.ready()   # 使用 ready() 判断任务是否执行完毕
False
>>> result.ready()
False
>>> result.ready()
True
>>> result.get()     # 使用 get() 获取任务结果
8
在上面，我们是在 Python 的环境中调用任务。事实上，我们通常在应用程序中调用任务。比如，将下面的代码保存为  client.py : 

from tasks import add

# 异步任务
add.delay(2, 8)

print 'hello world'

运行命令 $ python client.py，可以看到，虽然任务函数 add 需要等待 5 秒才返回执行结果，但由于它是一个异步任务，不会阻塞当前的主程序，因此主程序会往下执行 print 语句，打印出结果。

使用配置

在上面的例子中，我们直接把 Broker 和 Backend 的配置写在了程序当中，更好的做法是将配置项统一写入到一个配置文件中，通常我们将该文件命名为 celeryconfig.py。Celery 的配置比较多，可以在官方文档查询每个配置项的含义。

下面，我们再看一个例子。项目结构如下：

celery_demo                    # 项目根目录
    ├── celery_app             # 存放 celery 相关文件
    │   ├── __init__.py
    │   ├── celeryconfig.py    # 配置文件
    │   ├── task1.py           # 任务文件 1
    │   └── task2.py           # 任务文件 2
    └── client.py              # 应用程序

__init__.py 代码如下：

# -*- coding: utf-8 -*-

from celery import Celery

app = Celery('demo')                                # 创建 Celery 实例
app.config_from_object('celery_app.celeryconfig')   # 通过 Celery 实例加载配置模块

celeryconfig.py 代码如下：

BROKER_URL = 'redis://127.0.0.1:6379'               # 指定 Broker
CELERY_RESULT_BACKEND = 'redis://127.0.0.1:6379/0'  # 指定 Backend

CELERY_TIMEZONE='Asia/Shanghai'                     # 指定时区，默认是 UTC
# CELERY_TIMEZONE='UTC'                             

CELERY_IMPORTS = (                                  # 指定导入的任务模块
    'celery_app.task1',
    'celery_app.task2'
)

task1.py 代码如下：

import time
from celery_app import app

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

task2.py 代码如下：

import time
from celery_app import app

@app.task
def multiply(x, y):
    time.sleep(2)
    return x * y

client.py 代码如下：

# -*- coding: utf-8 -*-

from celery_app import task1
from celery_app import task2

task1.add.apply_async(args=[2, 8])        # 也可用 task1.add.delay(2, 8)
task2.multiply.apply_async(args=[3, 7])   # 也可用 task2.multiply.delay(3, 7)

print 'hello world'

现在，让我们启动 Celery Worker 进程，在项目的根目录下执行下面命令：

celery_demo $ celery -A celery_app worker --loglevel=info
接着，运行  $ python client.py ，它会发送两个异步任务到 Broker，在 Worker 的窗口我们可以看到如下输出： 

INFO/MainProcess] Received task: celery_app.task1.add[9ccffad0-aca4-4875-84ce-0ccfce5a83aa]
[INFO/MainProcess] Received task: celery_app.task2.multiply[64b1f889-c892-4333-bd1d-ac667e677a8a]
[INFO/PoolWorker-3] Task celery_app.task1.add[9ccffad0-aca4-4875-84ce-0ccfce5a83aa] succeeded in 2.00600231002s: 10
[INFO/PoolWorker-4] Task celery_app.task2.multiply[64b1f889-c892-4333-bd1d-ac667e677a8a] succeeded in 2.00601326401s: 21

delay 和 apply_async

在前面的例子中，我们使用 delay() 或 apply_async() 方法来调用任务。事实上，delay 方法封装了 apply_async，如下：

def delay(self, *partial_args, **partial_kwargs):
    """Shortcut to :meth:`apply_async` using star arguments."""
    return self.apply_async(partial_args, partial_kwargs)

也就是说，delay 是使用 apply_async 的快捷方式。apply_async 支持更多的参数，它的一般形式如下：

apply_async(args=(), kwargs={}, route_name=None, **options)

apply_async 常用的参数如下：

  • countdown：指定多少秒后执行任务

task1.apply_async(args=(2, 3), countdown=5) # 5 秒后执行任务

  • eta (estimated time of arrival)：指定任务被调度的具体时间，参数类型是 datetime

from datetime import datetime, timedelta

# 当前 UTC 时间再加 10 秒后执行任务
task1.multiply.apply_async(args=[3, 7], eta=datetime.utcnow() + timedelta(seconds=10))

  • expires：任务过期时间，参数类型可以是 int，也可以是 datetime

task1.multiply.apply_async(args=[3, 7], expires=10) # 10 秒后过期

更多的参数列表可以在官方文档中查看。

定时任务

Celery 除了可以执行异步任务，也支持执行周期性任务（Periodic Tasks），或者说定时任务。Celery Beat 进程通过读取配置文件的内容，周期性地将定时任务发往任务队列。

让我们看看例子，项目结构如下：

celery_demo                    # 项目根目录
    ├── celery_app             # 存放 celery 相关文件
        ├── __init__.py
        ├── celeryconfig.py    # 配置文件
        ├── task1.py           # 任务文件
        └── task2.py           # 任务文件

__init__.py 代码如下：

# -*- coding: utf-8 -*-

from celery import Celery

app = Celery('demo')
app.config_from_object('celery_app.celeryconfig')

celeryconfig.py 代码如下：

# -*- coding: utf-8 -*-

from datetime import timedelta
from celery.schedules import crontab

# Broker and Backend
BROKER_URL = 'redis://127.0.0.1:6379'
CELERY_RESULT_BACKEND = 'redis://127.0.0.1:6379/0'

# Timezone
CELERY_TIMEZONE='Asia/Shanghai'    # 指定时区，不指定默认为 'UTC'
# CELERY_TIMEZONE='UTC'

# import
CELERY_IMPORTS = (
    'celery_app.task1',
    'celery_app.task2'
)

# schedules
CELERYBEAT_SCHEDULE = {
    'add-every-30-seconds': {
         'task': 'celery_app.task1.add',
         'schedule': timedelta(seconds=30),       # 每 30 秒执行一次
         'args': (5, 8)                           # 任务函数参数
    },
    'multiply-at-some-time': {
        'task': 'celery_app.task2.multiply',
        'schedule': crontab(hour=9, minute=50),   # 每天早上 9 点 50 分执行一次
        'args': (3, 7)                            # 任务函数参数
    }
}

task1.py 代码如下：

import time
from celery_app import app

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

task2.py 代码如下：

import time
from celery_app import app

@app.task
def multiply(x, y):
    time.sleep(2)
    return x * y

现在，让我们启动 Celery Worker 进程，在项目的根目录下执行下面命令：

celery_demo $ celery -A celery_app worker --loglevel=info

接着，启动 Celery Beat 进程，定时将任务发送到 Broker，在项目根目录下执行下面命令：

celery_demo $ celery beat -A celery_app
celery beat v4.0.1 (latentcall) is starting.
__    -    ... __   -        _
LocalTime -> 2016-12-11 09:48:16
Configuration ->
    . broker -> redis://127.0.0.1:6379//
    . loader -> celery.loaders.app.AppLoader
    . scheduler -> celery.beat.PersistentScheduler
    . db -> celerybeat-schedule
    . logfile -> [stderr]@%WARNING
    . maxinterval -> 5.00 minutes (300s)

之后，在 Worker 窗口我们可以看到，任务 task1 每 30 秒执行一次，而 task2 每天早上 9 点 50 分执行一次。

在上面，我们用两个命令启动了 Worker 进程和 Beat 进程，我们也可以将它们放在一个命令中：

$ celery -B -A celery_app worker --loglevel=info

Celery 周期性任务也有多个配置项，可参考官方文档。

本文由 funhacks 发表于个人博客，采用 Creative Commons BY-NC-ND 4.0（自由转载-保持署名-非商用-禁止演绎）协议发布。
非商业转载请注明作者及出处。商业转载请联系作者本人。
本文标题为: 异步任务神器 Celery 简明笔记
本文链接为: https://funhacks.net/2016/12/...

参考资料





yanyangjie
关注
专栏目录
Celery 异步
小温在逆袭的博客
02-04 261
1.Celery介绍 1.1 celery应用举例 Celery 是一个 基于python开发的分布式异步消息任务队列，通过它可以轻松的实现任务的异步处理，如果你的业务场景中需要用到异步任务，就可以考虑使用celery 你想对100台机器执行一条批量命令，可能会花很长时间 ，但你不想让你的程序等着结果返回，而是给你返回 一个任务ID,你过一段时间只需要拿着这个任务id就可以拿到任务执行结果， 在任务执行ing进行时，你可以继续做其它的事情 Celery 在执行任务时需要通过一个消息中间件来接收和发送任务消
celery 异步任务
jntmjntm的博客
05-17 1074
1.celery介绍 Celery 是一个专注于实时处理和任务调度的分布式任务队列,本身不是任务队列, 是管理分布式任务队列的工具.任务队列采用redis中的list或mq实现,有5个常用组件 Task 就是任务，有异步任务和定时任务 Beat 定时任务调度器，根据配置定时将任务发送给Broker。 Broker 中间人，接收生产者发来的消息即Task，将任务存入队列。任务的消费者是Worker。 Worker 执行任务的单元，它实时监控消息队列，如果有任务就获取任务并执行它。 Backend 用于
Celery-异步
weixin_39422137的博客
04-24 1826
Celery-异步1.创建一个简单的celery任务 1.创建一个简单的celery任务 windows下使用celery需要先安装pip install eventlet 否则会报错 引用函数库 import celery import time 配置celery参数 broker = 'redis://127.0.0.1:6379/0' backend = 'redis://127.0.0.1:6379/1' cel = celery.Celery('tes', broker=broker, b
celery 重启
最新发布
youhebuke225的博客
09-06 890
重新启动Celery worker可以通过多种方式进行，具体取决于你是如何管理这些worker的。手动重新启动适用于简单的环境，而使用进程管理工具或Celery的内置命令则更适合生产环境和复杂的部署场景。如果你有特定的需求或遇到问题，请提供更多细节以便进一步讨论。
Celery异步任务
weixin_46072106的博客
11-07 1672
1. 简介 Celery 是一个异步任务队列。你可以使用它在你的应用上下文之外执行任务。总的想法就是你的应用程序可能需要执行任何消耗资源的任务都可以交给任务队列，让你的应用程序自由和快速地响应客户端请求。 使用 Celery 运行后台任务并不像在线程中这样做那么简单。但是好处多多，Celery 具有分布式架构，使你的应用易于扩展。 1.1 定义 Celery是一个基于Python开发的分布式异步消息任务队列，它非常易于使用。通过它可以轻松的实现任务的异步处理， 如果你的业务场景中需要用到异步任务，就可以考虑
celery应用--异步任务
liulanba的博客
09-11 1999
无论是使用 delay() 方法还是 apply_async() 方法，它们都会将任务发送到 Celery 的消息队列中进行异步执行，可以通过返回的 AsyncResult 对象来跟踪任务的执行状态和获取结果。apply_async() 方法是静态方法，需要显式创建任务实例，并可以设置更多的参数来控制任务调度和执行，适用于需要更高级配置的任务调用。delay() 方法是通过任务实例的简化方法来调用任务，不需要显式创建任务实例，适用于简单的任务调用。要触发异步任务，可以在你的代码中调用定义的异步任务函数。
celery与redis数据实现异步分布式搭建
weixin_45230787的博客
08-11 685
（一）celery框架简介             Celery 是一个简单的，灵活的，可靠的python编写处理大量消息的分布式系统。            &nbsp...
Django Celery异步任务队列的实现
09-19
Django Celery异步任务队列的实现是一个关键的技术，特别是在构建高性能的Web应用程序时，它可以帮助处理那些耗时的任务，提高用户体验。异步任务队列允许将长时间运行的操作从主线程分离出来，使得Web服务器可以...
Celery分布式异步任务处理框架
weixin_44767770的博客
06-19 474
1. Celery 简介 Celery是一个自带电池的基于Python开发的分布式异步任务队列，分布式决定了可以有多个 worker 的存在，队列表示其是异步操作，即存在一个产生任务提出需求的工头，和一群等着被分配工作的码农。它非常易于使用，通过它可以轻松的实现任务的异步处理， 如果你的业务场景中需要用到异步任务，就可以考虑使用Celery。它主要适用于两大类场景： 异步： 有的任务执行时间较长，你不想让程序一直等待结果返回，可以先将改任务放入celery任务队列中，并从Celery获取一个任务ID。后
Python-xTAS是基于Celery的分布式文本分析套件
08-10
Celery是一个强大的异步任务队列，它支持多种消息代理，如RabbitMQ或Redis，用于在分布式环境中协调任务执行。在Python-xTAS中，Celery帮助处理大量文本数据，确保高效且可扩展的处理能力。 **Celery框架详解** ...
django+celery异步发送邮件
12-27
而Celery则是一个分布式任务队列，它使得开发者能够轻松地处理异步任务，提高应用的响应速度和用户体验。本篇文章将深入探讨如何结合Django与Celery实现异步发送邮件的功能。 首先，我们需要理解异步处理的重要性。...
celery（异步服务）
时光偏执的博客
01-13 936
Celery简介 Celery是一个功能完备即插即用的任务队列 celery适用异步处理问题，当发送邮件，或者文件上传，图像处理等耗时操作，我们可以将其异步执行，这样用户就不用等待很久，提高用户体验 celery特点： 简单：易于使用和维护，有丰富的文档 高效：单个celery进程每分钟可以处理数百万个任务 灵活：celery中几乎每个部分都可以自定义扩展 celery非常易于集成到一些web开...
Django(6)|Celery异步组件
不愿意透露姓名的网友
10-08 1419
1.定义在web开发中，要给用户发送邮件，发送短息，都属于耗时的操作，会导致给用户的响应时间变长，这种情况的解决办法，给用户先返回一个响应，不要影响用户的使用，将这些耗时的操作，放在后台执行，例如新开一个进程，celery就是解决这个问题而生2.celery组成部分worker：执行任务的单元，可以理解为一个一个的线程任务，并发的执行。broker：消息中间件 ，用来在服务和woker中传递消息。Celery本身不提供消息服务，但是可以方便的和第三方提供的消息中间件集成。
Celery+python+redis异步执行定时任务
热门推荐
皓阳当空-博客
01-14 2万+
Celery+python+redis异步执行定时任务我之前的一篇文章中写了【Celery+django+redis异步执行任务】 博文:http://blog.csdn.net/apple9005/article/details/54236212 你会发现，这些代码并不依赖django框架，随便写到一个py文件中，就可以轻松的执行成功，这是因为这些代码并没有用到django-celery，dj
分布式框架Celery
yjjpp2301的专栏
06-25 1108
celery 是开源的，有很多的使用者celery 完全基于 Python 语言编写所以 celery 本质上是一个分布式的异步任务调度框架，类似于 Apache 的 airflowcelery 只是用来调度任务的，但它本身并不具备存储任务的功能，而调度任务的时候肯定是要把任务存起来的。因此要使用 celery 的话，还需要搭配一些具备存储、访问功能的工具，比如：消息队列、Redis缓存、数据库等等。官方推荐的是消息队列 RabbitMQ，我们使用 Redis。
Celery 异步介绍
weixin_65849268的博客
03-08 296
Celery是一个简单、灵活且可靠的，处理大量消息的分布式系统，专注于实时处理的异步任务队列，同时也支持任务调度。Celery 是一个 基于python的分布式异步任务队列，通过它可以轻松的实现任务的异步处理以celery集群的形式，celery的五大核心任务，耗时任务；定时任务broker,消息中间件 worker 工作者，并发执行beat：定时任务调度器backend：存储任务的执行结果。
celery异步任务
m0_59573674的博客
06-17 110
celery异步任务
使用celery实现异步任务
Roronoa_zoro0526的博客
11-05 1021
使用celery实现异步任务 了解Celery： ​ celery是一种即插即用的任务队列。 ​ celery适合异步处理任务，如发送短信、邮件、文件上传、图像处理等比较耗时的操作，可将其异步执行，用户不需要等待太多时间，提高用户体验。 特点： ​ 简单易于使用。 ​ 高效，单个celery进程每分钟可以处理数百万个任务 ​ 灵活：celery中几乎每个部分都可以自定义扩展 ​ celery非常易...
Celery：分布式任务队列详解
"Celery 是一个基于分布式消息传递的异步任务队列，主要用于处理大量消息，同时提供实时处理和任务调度功能。它由 Python 编写，但具有跨语言支持，如 Ruby 的 RCelery、node.js 的 node-celery 和 PHP 客户端。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值