23、在Python Flask应用中注入Rust

最新推荐文章于 2025-11-01 09:34:46 发布

flink9streamer

最新推荐文章于 2025-11-01 09:34:46 发布

阅读量14

点赞数

CC 4.0 BY-SA版权

分类专栏： Rust赋能Python高性能编程文章标签： Python Flask Rust

本文链接：https://blog.youkuaiyun.com/flink9streamer/article/details/151198082

Rust赋能Python高性能编程专栏收录该内容

26 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

在Python Flask应用中注入Rust

在Python Web应用开发中，有时候我们希望在不重写整个基础设施的情况下，提升应用的性能。而Rust以其高性能和安全性，成为了一个很好的选择。本文将介绍如何将Rust融入到Python Flask应用中，以及如何部署相关应用。

技术要求

代码和数据可在此处找到。
本文将构建一个Docker容器化的Flask应用，该应用可从此GitHub仓库获取。

将Rust融入Flask和Celery

为了在不做大的架构更改的情况下加速Flask应用，我们将通过pip安装Rust的斐波那契计算库，并在视图和Celery任务中使用它。具体步骤如下：
1. 定义对Rust斐波那契数计算包的依赖 ：
- 不建议直接将Rust依赖放在 requirements.txt 文件中，因为自动化更新该文件可能会删除GitHub仓库依赖。
- 我们可以创建一个新的文本文件 src/git_repos.txt ，并添加以下依赖：

git+https://github.com/maxwellflitton/flitton-fib-rs@main

- 使用以下命令安装GitHub仓库依赖：

pip install -r git_repos.txt

用Rust构建计算模块 ：
- 计算模块的结构如下：

src
├── fib_calcs
│   ├── __init__.py
│   ├── enums.py
│   └── fib_calculation.py

- 在`enums.py`文件中定义枚举：

from enum import Enum

class CalculationMethod(Enum):
    PYTHON = "python"
    RUST = "rust"

- 在`src/fib_calcs/__init__.py`文件中构建接口：

import time
from flitton_fib_rs.flitton_fib_rs import fibonacci_number
from fib_calcs.enums import CalculationMethod
from fib_calcs.fib_calculation import FibCalculation

def _time_process(processor, input_number):
    start = time.time()
    calc = processor(input_number)
    finish = time.time()
    time_taken = finish - start
    return calc, time_taken

def _process_method(input_method):
    calc_enum = CalculationMethod._value2member_map_.get(input_method)
    if calc_enum is None:
        raise ValueError(
            f"{input_method} is not supported, "
            f"please choose from "
            f"{CalculationMethod._value2member_map_.keys()}")
    return calc_enum

def calc_fib_num(input_number, method):
    if isinstance(method, str):
        method = _process_method(input_method=method)
    if method == CalculationMethod.PYTHON:
        calc, time_taken = _time_process(
            processor=FibCalculation,
            input_number=input_number
        )
        return calc.fib_number, time_taken
    elif method == CalculationMethod.RUST:
        calc, time_taken = _time_process(
            processor=fibonacci_number,
            input_number=input_number
        )
        return calc, time_taken

在Flask应用中创建使用Rust的计算视图 ：
- 在 src/app.py 文件中导入接口：

from fib_calcs import calc_fib_num
from fib_calcs.enums import CalculationMethod

- 修改标准计算视图：

@app.route("/calculate/<int:number>")
def calculate(number):
    fib_calc = dal.session.query(FibEntry).filter_by(
        input_number=number).one_or_none()
    if fib_calc is None:
        if number < 50:
            fib_number, time_taken = calc_fib_num(
                input_number=number,
                method=CalculationMethod.PYTHON
            )
            return f"you entered {number} " \
                   f"which has a Fibonacci number of " \
                   f"{fib_number} which took {time_taken}"

- 创建Rust计算视图：

@app.route("/rust/calculate/<int:number>")
def rust_calculate(number):
    fib_calc = dal.session.query(FibEntry).filter_by(
        input_number=number).one_or_none()
    if fib_calc is None:
        if number < 50:
            fib_number, time_taken = calc_fib_num(
                input_number=number,
                method=CalculationMethod.RUST
            )
            return f"you entered {number} " \
                   f"which has a Fibonacci number of " \
                   f"{fib_number} which took {time_taken}"

将Rust插入到Celery任务中 ：
- 在 src/task_queue/fib_calc_task.py 文件中导入参数和接口：

from config import GlobalParams
from fib_calcs import calc_fib_num

- 重构Celery任务：

def create_calculate_fib(input_celery):
    @input_celery.task()
    def calculate_fib(number):
        params = GlobalParams()
        fib_number, _ = calc_fib_num(input_number=number,
                                     method=params.get(
                                         "CELERY_METHOD", 
                                         "rust"))
        fib_entry = FibEntry(input_number=number,
            calculated_number=fib_number)
        dal.session.add(fib_entry)
        dal.session.commit()
    return calculate_fib

部署带有Rust的Flask和Celery

为了让Flask应用的Docker镜像支持Rust包，需要对 src/Dockerfile 文件进行一些更改：

RUN apt-get update -y
RUN apt-get install -y python3-dev python-dev gcc
# setup rust
RUN curl https://sh.rustup.rs -sSf | bash -s -- -y –profile minimal –no-modify-path
# Add .cargo/bin to PATH
ENV PATH="/root/.cargo/bin:${PATH}"
# Install the dependencies
RUN pip install --upgrade pip setuptools wheel
RUN pip install -r requirements.txt
RUN pip install -r git_repos.txt

在 src 目录的根目录下，使用以下命令构建Docker镜像：

docker build . -t flask-fib

使用私有GitHub仓库进行部署

当使用私有GitHub仓库时，直接构建Docker镜像会遇到认证问题。可以通过以下步骤解决：
1. 构建一个Bash脚本来编排整个过程 ：
- 在 src/build_image.sh 文件中编写脚本：

#!/usr/bin/env bash
SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
cd $SCRIPTPATH
git clone https://github.com/maxwellflitton/flitton-fib-rs.git
rm -rf ./flitton-fib-rs/.git
docker build . --no-cache -t flask-fib
rm -rf ./flitton-fib-rs

重新配置 Dockerfile 中的Rust Fib包安装 ：通过上述Bash脚本克隆包并传递到镜像构建中。

通过以上步骤，我们就可以将Rust成功融入到Python Flask应用中，并进行有效的部署。这样可以在不重写整个基础设施的情况下，提升应用的性能。

总结

本文详细介绍了将Rust融入Python Flask应用的具体步骤，包括依赖定义、模块构建、视图创建、任务插入以及部署等方面。通过这些操作，我们可以在不改变现有架构的前提下，显著提升应用的性能。同时，针对使用私有GitHub仓库部署时的问题，也给出了相应的解决方案。希望这些内容能帮助你在实际项目中更好地利用Rust和Python的优势。

在Python Flask应用中注入Rust

技术点分析

Rust与Flask、Celery融合的优势
- 性能提升 ：从实际测试输出可以看到，Rust调用比Python调用快四倍，即使Rust请求的数字更大。这是因为Rust的编译性质使其在执行计算密集型任务时具有更高的效率，能够显著加速Flask应用的计算过程。
- 代码安全性 ：Rust具有强大的内存安全和并发安全特性，在与Flask和Celery集成时，可以减少因内存泄漏、数据竞争等问题导致的错误，提高应用的稳定性和可靠性。
- 灵活性 ：通过定义枚举和接口，我们可以轻松地在Python和Rust实现之间进行切换，根据不同的需求和场景选择最合适的计算方法。例如，在计算较小的斐波那契数时可以使用Python实现，而在处理大规模计算时则使用Rust实现。
部署过程中的注意事项
- Rust安装 ：在Dockerfile中安装Rust时，需要确保安装了必要的依赖，如 python3-dev 、 python-dev 和 gcc ，以便在使用Python时能够使用编译扩展。同时，要正确设置环境变量，将 .cargo/bin 添加到 PATH 中，确保Rust工具链可以被正确访问。
- 包编译 ：在安装Rust包时，可能会遇到编译时间较长的问题，这是因为pip需要编译Rust包。可以考虑使用更优化的分发策略，如在后续章节中可能会探讨的方法，以减少编译时间。
- 私有仓库访问 ：使用私有GitHub仓库时，需要注意安全问题。直接传递GitHub凭据到镜像构建中会存在安全风险，因此建议使用克隆包并传递到镜像构建的方法，避免凭据泄露。

操作流程总结

为了更清晰地展示整个过程，我们可以将操作步骤总结为以下流程图：

graph TD;
    A[定义Rust依赖] --> B[构建计算模块];
    B --> C[创建计算视图];
    C --> D[插入Rust到Celery任务];
    D --> E[修改Dockerfile支持Rust];
    E --> F[构建Docker镜像];
    F --> G[处理私有仓库部署];

常见问题及解决方案

问题	原因	解决方案
pip安装Rust包时构建挂起	包正在编译	等待编译完成，可考虑使用更优化的分发策略
私有GitHub仓库构建失败	未登录GitHub，无法拉取包	使用克隆包并传递到镜像构建的方法，如编写Bash脚本
镜像构建时某些步骤未更新	Docker缓存了未更改的层	使用 `--no-cache` 参数进行构建

进一步优化建议

缓存编译结果 ：在后续部署中，可以考虑使用缓存机制来避免每次安装Rust包时都进行编译，减少部署时间。例如，可以使用Docker的多阶段构建，将编译过程和运行过程分离，将编译结果缓存起来。
自动化部署 ：可以使用持续集成/持续部署（CI/CD）工具，如GitHub Actions、Travis等，自动化整个部署过程，提高部署效率和准确性。
性能监控 ：在应用部署后，可以使用性能监控工具来监控Rust和Python部分的性能，根据监控结果进一步优化代码和配置。

通过将Rust融入Python Flask应用，我们可以充分发挥两者的优势，在不重写整个基础设施的情况下提升应用的性能和安全性。同时，通过合理的部署和优化策略，可以确保应用的高效运行和稳定维护。希望本文的内容能为你在实际项目中应用Rust和Python提供有价值的参考。