使用celery做异步的clickhouse表导出--带去重和任务数控制

于 2024-08-09 07:00:00 发布
阅读量527 收藏 8
点赞数 4
分类专栏： 技术日志 文章标签： python clickhouse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/simulate_create/article/details/141017181
版权

问题描述

1. 背景

需要对clickhouse里的日志表进行导出，原有的API接口是通过REST API从clickhouse查询并通过HTTP传输，虽然给clickhouse的HTTP接口启用了压缩，但效率和资源利用仍然很低。要等待很长时间，页面可能会超时。原有的API值保留了很少的数据，不存在这个问题。但使用clickhouse后，数据保存的非常大，所以请求时间就很长了。

2. 目标

所以接下来的目标就是很明确了，因为时间长，要使用异步。因为数据量大，所以要更换更高效的导出方式。显然直接用数据库本身的导出方式，直接导出文件更高效。因为要防止用户反复请求统一个参数，因此任务要有管理。首先就是去重，防止重复下发同样的导出任务，第二个就是要限制并发或同时下载的任务数，防止吃太多CPU资源。因为clickhouse的查询通常都会消耗大量的硬盘、CPU、内存资源，尤其是CPU。

目标：异步，利用数据库的导出功能，任务要有数量和状态管理。

3. 方案

根据以往的经验，celery就可以做异步任务。所以直接选定了celery，clickhouse-client的导出。而任务要有状态管理，可以在redis里管理状态。

方案：celery做异步，clickhouse-client直接导出压缩文件。对任务在redis管理。

接下来，就是如何实现。首先从celery执行一个简单任务开始。

一、clickhouse表的导出

clickhouse可以直接导出到压缩文件（见引用），格式也可以支持多种多样。我们需要的压缩的csv格式，因此只需要提供csv.gz的文件名后缀即可。

SELECT *
FROM nyc_taxi
INTO OUTFILE 'taxi_rides.tsv.gz'

根据不同表、不同起止时间查询，可以得出SQL模板：

select * from {table_name} where {time_field} >= {start_time} and {time_field}  < {end_time}
INTO OUTFILE '{filename}'
format CSVWithNames
SETTINGS max_threads = {max_threads}

 这里有两个问题需要解决：

1. clickhouse的HTTP客户端不能使用导出的INTO OUTFILE语句。

所以只能封装一个使用clickhouse-client的命令调用导出，celery的worker也需要和clickhouse运行在一起。

def execute_query_local(query, database):
    # 启动子进程执行命令：
    # clickhouse-client --query  query
    ret = subprocess.check_call(["clickhouse-client","-d", database, "--query", query], shell=False)
    return ret

2. 导出数据的CPU消耗很大，因此要限制一下线程数，以降低消耗。我使用了10个线程。时间长是可以忍受的，但崩溃是无法忍受的。

SETTINGS max_threads = 10

二、celery异步任务

1. 最小可用

首先，一个celery的最小可用任务，这没有什么难度。可以借助chatgpt完成。这里直接贴出相关的代码。

要利用Redis进行异步任务处理，你可以使用一个Python库如Celery。Celery是一个简单、灵活且可靠的分布式系统来处理大量消息，旨在实现实时操作。它的设计灵活，能够与各种各样的队列、数据库和消息传递系统进行集成。

以下是一个基本示例，展示了如何使用Celery和Redis来执行异步任务、跟踪任务状态并获取任务结果。

  1. 安装依赖：

    首先，确保你已经安装了Celery和Redis：

    pip install celery redis

  2. 创建Celery应用：

    这是你的celery_app.py文件：
     

    from celery import Celery

    # 创建Celery实例，并设置Redis为broker和backend
    app = Celery('tasks', broker='redis://localhost:6379/0', backend='redis://localhost:6379/0')

    # 定义一个简单的任务
    @app.task
    def add(x, y):
        return x + y
     

  3. 编写异步任务处理代码：

    这是你的main.py文件，用于发送任务并获取其状态和结果：

    from celery_app import add

# 发送任务
result = add.delay(4, 6)

# 跟踪任务状态
print(f'Task state: {result.state}')

# 等待任务完成并获取结果
result_value = result.get(timeout=10)
print(f'Task result: {result_value}')

  4. 启动Celery Worker：

    在命令行中运行以下命令以启动Celery worker：

    celery -A celery_app worker --loglevel=info

    这会启动一个Celery worker进程，监听任务并处理它们。

  5. 运行主程序：

    在另一个命令行窗口中运行你的主程序：

    python main.py

    你应该会看到任务的状态和结果：

    Task state: PENDING Task result: 10

这个例子展示了如何利用Celery和Redis实现一个简单的异步任务处理系统。你可以根据需要扩展和自定义任务、状态跟踪和结果处理等功能。

需要注意的是windows要使用eventlet：

celery -A tasks.export_tasks worker --loglevel=info -P eventlet

2. 去重的任务

celery基本上就是任务发出去就不管了，要看任务状态，拿着task_id去查询。我们想要对请求参数进行去重。这里有找到一个celery-unique（见引用）的组件，可以对任务去重。

其使用方法是（来源于github，见引用）：

a. 设置celery

# my_application/__init__.py
#
# Create and configure Celery app object, as usual
from celery import Celery

celery_app = Celery()

# Add celery-unique capabilities to the original Celery Task class
from celery_unique import unique_task_factory

task_base_cls = celery_app.Task
new_task_cls = unique_task_factory(task_base_cls)
celery_app.Task = new_task_cls

b.设置唯一任务

# my_application/celery_tasks.py
from . import celery_app
from redis import Redis

my_redis_client = Redis()

# Configure a unique task by providing a key-generator and Redis
# connection as `unique_key` and `redis_client` keyword arguments,
# respectively.

@celery_app.task(
    unique_key=lambda a, b, c=0: '{} with {}'.format(a, c), 
    redis_client=my_redis_client
)
def add_first_and_last(a, b, c=0):
    return a + c

c. 运行任务

import time
from my_application.celery_tasks import add_first_and_last

# Unique-handling will only take effect when the above functions are called
# via `apply_async()` with an ETA or countdown...
async_result_1 = add_first_and_last.apply_async(args=(1, 2, 3), countdown=100)
async_result_2 = add_first_and_last.apply_async(args=(3, 2, 1), countdown=100)
async_result_3 = add_first_and_last.apply_async(
    args=(1, 2), 
    kwargs={'c': 3}, 
    countdown=50
)

# Wait 100 seconds for all tasks to complete
time.sleep(100)

# Check and see the status of each task
assert async_result_1.status == 'REVOKED'
assert async_result_2.status == 'SUCCESS'
assert async_result_3.status == 'SUCCESS'

 在使用时，发现其功能和我们的目的不太相同，因此这里做了一些简单的修改。

a. 首先是判断是否超出限制数量，如果超出限制抛出异常。

    def _check_task_limit(self, unique_redis_key, options):
        if 'max_task_limit' in options:
            max_task_limit = options['max_task_limit']
            if max_task_limit is not None:
                redis_key = '{prefix}:{task_name}:*'.format(
                    prefix=UNIQUE_REDIS_KEY_PREFIX,
                    task_name=self.name)
                keys = self.redis_client.keys(redis_key)
                if unique_redis_key in keys:
                    return
                if len(keys) > max_task_limit:
                    raise TaskLimitExceeded('Task limit exceeded')

b. 其次是判断任务状态，如果是重复任务则查询旧任务的任务结果，并返回。

    def _check_task_return(self, redis_key):
        """Given a Redis key, return the corresponding record if one exists.

        @param redis_key: The string (potentially) used by Redis as the key for the record
        @type redis_key: str | unicode
        """
        task_id = self.redis_client.get(redis_key)
        if task_id is not None:
            async_result = AsyncResult(task_id,app=self.app)
            if async_result.successful():            
                self.redis_client.delete(redis_key)
            if async_result.failed():            
                self.redis_client.delete(redis_key)
                async_result.forget()
            return async_result

这样，我们就有了一个可以去重、判断任务数量、获取当前任务状态的组件了。需要celery-unique的，可以去资源下载源文件。实际使用是：

import os
import time
from celery import Celery
from .celery_unique import unique_task_factory, TaskLimitExceeded
from redis import Redis
from .config import REDIS_HOST, REDIS_PORT
import subprocess

my_redis_client = Redis(host=REDIS_HOST, port=REDIS_PORT,db=0)


app = Celery('tasks', 
             broker=f'redis://{REDIS_HOST}:{REDIS_PORT}/0',
             backend=f'redis://{REDIS_HOST}:{REDIS_PORT}/0'
             )

task_base_cls = app.Task
new_task_cls = unique_task_factory(task_base_cls)
app.Task = new_task_cls

def export_table_query(id, table_name, start_time, end_time, filename, max_threads=10):
    ...
    return query

def execute_query_local(query, database='cdn'):
    ...
    return ret

@app.task(
    unique_key=lambda id,*args: '{}'.format(id), 
    redis_client=my_redis_client,
)
def export_table(id, table_name, start_time, end_time, filename, max_threads=10):
    query = export_table_query(id, table_name, start_time, end_time, filename, max_threads=max_threads)
    if os.path.exists(filename):
        return os.path.split(filename)[-1]
    ret = execute_query_local(query, 'mydb')
    return os.path.split(filename)[-1]

其中，去重的是id，当然也可以修改成其它的方式，只需要修改unique_key即可。接下来就要在API里调用了这个方法了。

三、导出表的API接口

1. API调用

try:
    filename = get_file_name(id, table, start_time, end_time, format, CACHE_PATH)
    task = export_table.apply_async(args=(id, table, start_time, end_time, filename), 
                task_record_timeout=MAX_WAIT_SEC, expires=MAX_WAIT_SEC,
                max_task_limit=MAX_TASK_LIMIT)
    try:
        task.wait(timeout=1)
    except:
        pass
except TaskLimitExceeded:
    return error_return("并行任务数量超过限制，请等待现有完成。")

2. 状态查询

可以直接将task的state返回，如果是相同的请求参数（去重规则相同），就会获取到同样的任务id。无需提供额外的任务id存储或者记录。

return dict(
        task_id=task.id,
        task_status=task.state,
        filename=str(task.get()) if task.state == 'SUCCESS' else ""
    )

3. 下载文件

在下载文件的时候，要调整media_type和文件名。由于使用的是FastAPI框架，以此为例，其他框架同理：

from fastapi.responses import StreamingResponse, FileResponse

@router.get("/download", summary="下载文件", response_class=FileResponse)
async def download(filename):
    
    if os.path.exists(CACHE_PATH) and filename in os.listdir(CACHE_PATH):
        if filename.endswith('.gz'):
            return FileResponse(f'{CACHE_PATH}/{filename}', media_type='application/x-gzip', filename=filename)
        else:
            return FileResponse(f'{CACHE_PATH}/{filename}', filename=filename)
    else:
        raise HTTPException(status_code=404, detail="File not found")

总结：

至此所有功能就完成。主要内容：

1. 导出clickhouse数据，对其封装。

2. 确定异步执行任务，并对任务数量进行管控，及状态查询。并编写导出任务。

3. 封装API，以及提供文件下载接口。

引用：

How do I export data from ClickHouse to a file? | ClickHouse Docs

Formats for Input and Output Data | ClickHouse Docs

FORMAT Clause | ClickHouse Docs

GitHub - shiftgig/celery-unique: Python factory for limiting Celery tasks by configuration

Responses - Starlette

想象造物
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Django项目中使用celery做异步任务_django中celery实现异步
m0_63174618的博客
04-21 1108
这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。基本上主流的和经典的都有，这里我就不放图了，版权问题，个人看看是没有问题的。
使用celery和Django处理异步任务的流程分析
09-17
总结起来，结合Celery和Django，我们可以轻松地实现异步任务处理，提升应用性能和用户体验。Celery提供了丰富的功能，如任务结果存储、定时任务（beat）以及任务重试策略，能够满足复杂的应用场景需求。通过以上步骤...
使用 Flask 和 Celery 构建异步任务处理应用
Code掘金的博客
05-21 943
Flask是一个轻量级的Python Web框架，它提供了简单易用的方式来构建Web应用程序。Flask具有灵活的扩展性，允许开发者根据项目的需求选择适合的组件和库。Celery是一个分布式任务队列，它可以处理大量的异步任务。Celery提供了一个简单而强大的API，可以轻松地将任务分配给多个工作进程，并提供任务状态监控和结果存储等功能。
celery应用--异步任务
liulanba的博客
09-11 1824
无论是使用 delay() 方法还是 apply_async() 方法，它们都会将任务发送到 Celery 的消息队列中进行异步执行，可以通过返回的 AsyncResult 对象来跟踪任务的执行状态和获取结果。apply_async() 方法是静态方法，需要显式创建任务实例，并可以设置更多的参数来控制任务调度和执行，适用于需要更高级配置的任务调用。delay() 方法是通过任务实例的简化方法来调用任务，不需要显式创建任务实例，适用于简单的任务调用。要触发异步任务，可以在你的代码中调用定义的异步任务函数。
celery----异步任务、延时任务、定时任务
淘淘桃的博客
06-29 765
Celery 是一个强大的分布式任务队列，它可以让任务的执行完全脱离主程序，甚至可以被分配到其他主机上运行。我们通常使用它来实现异步任务（async task）和定时任务（crontab）。
Django中使用celery完成异步任务的示例代码
09-20
在Django中，为了提升应用程序的性能和用户体验，常常需要将一些耗时的操作，比如邮件发送、数据分析等，从主线程中分离出来，通过异步任务来处理。Celery是一个强大的分布式任务队列，它专注于实时操作，但也支持...
详解Django中异步任务之django-celery
12-16
在Django中，异步任务的实现通常借助第三方库，如`django-celery`，它是一个基于Celery的集成方案，使得在Django项目中使用Celery变得更加方便。Celery是一个分布式任务队列，其核心特性是支持异步任务执行和定时...
python使用celery实现异步任务执行的例子
09-18
今天小编就为大家分享一篇python使用celery实现异步任务执行的例子，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Django异步任务之Celery的基本使用
09-19
在Django中，异步任务对于提升应用性能和用户体验至关重要，因为它们允许后台处理耗时操作，而不阻塞主线程。Celery是一个流行的开源任务队列，它支持多种消息代理，如RabbitMQ和Redis，使得分布式任务调度变得简单...
大模型微调工具-torchtune
weixin_40777649的博客
08-08 320
1.定义2.安装3. 案例。
python的匿名函数
weixin_74923758的博客
08-05 211
python中的匿名函数是一种简洁的函数定义方式，它使用lambda关键字来创建。匿名函数通常用于需要一个函数对象，但又不想去定义一个完整的函数时。它们可以接收任意数量的参数，但只能有一个表达式。匿名函数经常与函数的参数一起使用，例如map（），filter（）和sorted()等函数，这些函数可以接受一个函数作为参数来指定如何操作数据。map()函数可以将一个给定的函数应用于一个可迭代对象的每个元素。是函数体，它是一个表达式，其结果将作为函数的返回值。
数学建模之数据分析【先导片】
lmx1458070445的博客
08-05 1041
数据分析的定义为研究、清理、建模和转换数据，以找到有用的信息、提出结论并支持决策。
手机号码归属地查询接口如何对接？（二）
loosenivy的博客
08-04 193
手机号归属地查询可通过手机号查询归属地信息、是否虚拟运营商等。适用于金融、市场营销、电子商务等场景。
快速体验LLaMA-Factory 私有化部署和高效微调Llama3模型FAQ
IT菜鸟
08-05 1111
快速体验LLaMA-Factory 私有化部署和高效微调Llama3模型FAQ
NVIDIA-CUDA
最新发布
qq_41081716的博客
08-08 270
CUDA 是一种强大的并行计算平台，它极大地扩展了 GPU 的用途，使其不仅仅局限于图形处理。通过利用 CUDA，开发人员可以编写高效、高性能的并行应用程序，这些应用程序可以用于各种计算密集型任务。如果您正在从事高性能计算或需要加速计算任务的工作，CUDA 是一个非常有用的工具。
Python语法基础常识
2401_86168842的博客
08-07 311
初步学习print函数时，我们可以看到print函数分别有无引号、单引号、三引号用法，即print()、print(' ')、print(''' ''')用法，他们之间的用法分别是怎样的呢？number='3.1415926'，那么这行代码中，number就是变量，我们把数字“3.1415926”赋值给了number。print('')则是用于文字输出，当我们想要让计算机打出非纯数字内容时，就得在print函数中用单引号''。当然，可能有同学会好奇：“那我能不能不用单引号，用双引号呢？
java selenium 设置代理，允许在其他环境中使用不同的IP访问
huanghm88的专栏
08-05 472
此代码以Chrome浏览器为例，如果你使用其他浏览器，你需要相应地调整代码。另外，你需要下载适用于你的操作系统的Chrome浏览器驱动，并将路径替换为。在Java Selenium中设置代理可以使用。替换为其他环境中要访问的IP地址。替换为实际的代理IP和端口，并将。
【面试题】寻找两个正序数组的中位数
联系方式：927632640
08-06 468
面试学习给定两个大小分别为 m 和 n 的正序数组 nums1 和 nums2，我们需要找到这两个数组的中位数。下面是详细的解题步骤和 Python 代码示例。
celery异步任务
08-05
Celery是一个Python的分布式任务队列框架，它可以用来实现异步任务的调度与执行。使用Celery，你可以将耗时的任务放入任务队列中，然后由后台的工作进程异步执行，这样可以提高系统的并发能力和响应速度。 要使用Celery，首先需要安装Celery库。你可以使用pip命令进行安装： ``` pip install celery``` 接下来，你需要创建一个Celery实例，并定义任务函数。任务函数可以是任何可调用对象，通常是一个Python函数。例如，下面是一个简单的示例： ```pythonfrom celery import Celery# 创建Celery实例app = Celery('myapp', broker='redis://localhost:6379/0') # 定义任务函数@app.taskdef add(x, y): return x + y``` 在上面的示例中，我们创建了一个名为`myapp`的Celery实例，并指定了一个Redis作为消息代理（broker）。然后，我们定义了一个名为`add`的任务函数，使用`@app.task`装饰器来将其注册为Celery任务。 接下来，你可以使用`delay()`方法调用任务函数，将任务放入任务队列中异步执行： ```pythonresult = add.delay(4,6) ``` 在上面的示例中，我们使用`delay()`方法调用了`add`任务，并传递了两个参数4和6。这会将任务添加到Celery的任务队列中，并返回一个`AsyncResult`对象，你可以使用它来获取任务的执行结果。 当任务被放入任务队列后，你需要启动Celery的工作进程来执行任务。可以使用以下命令启动工作进程： ``` celery -A myapp worker --loglevel=info``` 上面的命令中，`-A`参数指定了Celery实例所在的模块（在这个例子中是`myapp`），`--loglevel=info`参数指定了日志级别为info。 这只是Celery的一些基本用法，还有很多其他功能和配置可以探索。你可以查阅Celery的官方文档来获取更多详细信息：https://docs.celeryproject.org/
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值