0 背景

在《部署深度学习模型时的全流程加密方案探索》一文中，我们介绍了几种 python 代码加密的方式，其中第一种是使用 Nuitka 工具进行封装，该工具首先将 py 文件转成 c 文件，然后编译成 .o 文件，最后合并成 .bin 可执行文件，从 bin 到 C 是不可逆的，从 C 到 Python 也是不可逆的，因此代码是安全的。工作量小，安全性高，使用加密之后的 Python 便捷；但编译时间长，过程复杂。本文对该工具的使用方法进行一个介绍

1 安装测试

1.1 安装方法

在官方的安装说明中，提供了不同平台的安装方法，我们在 linux 系统下，采用最简单的 pip 安装即可

pip install -U nuitka

安装好之后查看版本，可以看到安装的是最新的 0.6.17.7 版本。

$ python -m nuitka --version
0.6.17.7
Commercial: None
Python: 3.6.9 (default, Jan 26 2021, 15:33:00) 
Executable: /usr/bin/python
OS: Linux
Arch: aarch64

如果要查看帮助文档，使用下边的指令

$ python -m nuitka --help

1.2 简单测试

新建一个 python 测试脚本 hello.py

def talk(message):
    return "Talk " + message


def main():
    print(talk("Hello World"))


if __name__ == "__main__":
    main()

使用工具创建可执行文件，会生成 hello.bin 文件，从输出日志可以看到封装的过程

$ python -m nuitka --lto=no hello.py█████████████████████████████████████████████████████████████████████████| 10/10
Nuitka-Options:INFO: Used command line options: --lto=no hello.py
Nuitka-Options:INFO: Detected static libpython to exist, consider '--static-libpython=yes' for better performance.                                  
Nuitka:INFO: Starting Python compilation with Nuitka '0.6.17.7' on Python '3.6' commercial None.
Nuitka:INFO: Completed Python level compilation and optimization.                                                                                   
Nuitka:INFO: Generating source code for C backend compiler.
Nuitka:INFO: Running data composer tool for optimal constant value handling.                                                                        
Nuitka:INFO: Running C level backend compilation via Scons.
Nuitka-Scons:INFO: Backend C compiler: gcc (gcc).
Nuitka-Scons:WARNING: You are not using ccache.                                                                                                     
Nuitka:INFO: Keeping build directory 'hello.build'.
Nuitka:INFO: Successfully created 'hello.bin'.

运行成功后，测试一下生成的 bin 文件，输出成功，表明环境没问题

$ ./hello.bin 
Talk Hello World

2 使用方法

2.1 封装所有模块

如果想要把整个工程进行封装，而不是只封装一个主程序，则使用下边的方法

python -m nuitka --follow-imports program.py

注意：

1、在封装过程中，尽量少包含一些模块，这些模块使用普通的 python 脚本运行，这样速度会快一些。如果说你的工程中包含一些动态库，无法直接通过 PYTHONPATH 环境变量设置后直接导入的话，可以在封装过程中指定这些路径，如下

python -m nuitka --follow-imports --include-plugin-directory=plugin_dir program.py

2、生成的可执行文件依赖于 CPython 和 C 环境，如果你想要在另外一台设备上运行可执行文件，需要使用 --standalon 指令，并且拷贝 program.dist 路径，将可执行文件放到这个目录中

2.2 封装动态库

如果说你想把某些模块封装成动态库，需要使用 --module 指令，如下

python -m nuitka --module some_module.py

运行后会生成 some_module.so 动态库，可以被其他程序导入使用。注意生成的这个动态库只能被相同版本的 CPython 导入。

2.3 封装包

如果要封装整个包，并且一些模块使用动态库的方式，可以使用下边的方法

python -m nuitka --module some_package --include-package=some_package

2.4 程序分发

如果要将代码分发到其它系统中，可以通过指定 --standalone 指令来生成一个文件夹

python -m nuitka --standalone program.py

默认会导入所有的模块，如果要排除一些模块，可以使用 --nofollow-import-to 指令，但是在程序运行时可能会出现 ImportError

3 指令说明

来源：Python打包(pyinstaller&nuitka)_＠假装很文艺的文艺青年的博客-CSDN博客_nuitka打包python

3.1 常用参数

--mingw64 #默认为已经安装的vs2017去编译，否则就按指定的比如mingw

--standalone #独立文件，这是必须的

--follow-imports #把开头import的文件或者模块一起打包

--windows-disable-console #没有CMD控制窗口

--recurse-all #所有的资源文件 这个也选上

--recurse-not-to=numpy,jinja2 #不编译的模块，防止速度会更慢

--output-dir=out #生成exe到out文件夹下面去

--show-progress #显示编译的进度，很直观

--show-memory #显示内存的占用

--plugin-enable=pylint-warnings #报警信息

--plugin-enable=qt-plugins #需要加载的PyQT插件

--nofollow-imports # 所有的import不编译，交给python3x.dll执行

--follow-import-to=need # need为你需要编译成C/C++的py文件夹命名

--include-package #将python的requests包打包进exe

–include-plugin-directory #可以将某文件夹里的所有文件打包进执行档中，这里的路径需要写绝对路径

3.2 模块和包

--include-package=PACKAGE：
包含一个包。提供一个 Python 命名空间，比如：some_package.sub_package，然后 Nuitka 会找到它，并将磁盘中的它和它创建的二进制文件或所有扩展模块包括在内，并通过代码将其导入。默认为空。
--include-module=MODULE：
包含一个模块。和 --include-package 一样。默认为空。
--include-plugin-directory=MODULE/PACKAGE：
包含目录的内容，不管给定的主程序是否以可见的形式使用它。将重写其他所有递归选项。可以多次使用。默认为空。
--include-plugin-files=PATTERN：
包含所有匹配的文件。将覆盖所有递归选项。可以多次使用。默认为空。

3.3 模块递归

--follow-stdlib, --recurse-stdlib：
从标准库中导入模块。这将大大增加编译时间。默认关闭。
--nofollow-imports, --recurse-none：
当使用 --recure-none，将完全不导入任何模块，将覆盖所有其他的递归选项。默认关闭。
--follow-imports, --recurse-all：
当使用 --recurse-all 时，将导入所有模块。默认关闭。
--follow-import-to=MODULE/PACKAGE, --recurse-to=MODULE/PACKAGE：
递归指定的模块或包，可以多次使用。默认为空。
--nofollow-import-to=MODULE/PACKAGE, --recurse-not-to=MODULE/PACKAGE：
不递归指定的模块或包，将覆盖递归选项。可以多次使用。默认为空

3.4 编译后执行

--run：
立即执行创建的二进制文件（或导入编译的模块）。默认关闭。
--debugger, --gdb：
在 gdb 内执行，以自动获取堆栈跟踪。默认关闭。
--execute-with-pythonpath：
当立即执行创建的二进制文件时（--execute），不要重置 PYTHONPATH。当所有模块都成功包含时，你应该不再需要 PYTHONPATH。

3.5 输出选项

-o FILENAME：
指定应如何命名可执行文件。对于扩展模块而言，没有选择也没有独立模式，使用它将是一个错误。这可能包含需要存在的路径信息，默认为平台下的  程序名称。平台名称.exe。
--output-dir=DIRECTORY：
指定最终文件的输出目录。默认为当前目录。
--remove-output：
生成模块或 exe 文件之后删除生成目录。默认关闭。
--no-pyi-file：
不要为创建的扩展模块创建 .pyi 文件。这用于检测隐式导入。默认为关闭。

3.6 调试特性

--debug：
执行所有可能的自检以查找 Nuitka 中的错误，不适合生成环境。默认关闭。
--unstripped：
在生成的对象文件中保留调试信息，以便更好地进行调试器交互。默认关闭。
--profile：
启用基于 vmprof 的时间分析。默认关闭。
--graph：
创建优化过程图。默认关闭。
--trace-execution：
跟踪执行输出，在执行前输出代码行。默认关闭。
--recompile-c-only：
这不是增量编译，而是仅用于 Nuitka 开发。获取现有文件并将其重新编译为 C。允许编译编辑过的 C 文件，以便快速调试对生成源的更改，例如查看代码是否通过、值的输出等。默认关闭。
--generate-c-only：
只生成 C 源代码，不编译生成二进制文件或模块。这是为了调试和代码覆盖率分析，而不是浪费 CPU。默认关闭。
--experimental=EXPERIMENTAL：
使用声明为 experimental 的功能。如果代码中不存在任何实验功能，则可能没有效果。
--disable-dll-dependency-cache：
禁用依赖项的缓存。这将导致创建分发文件夹的时间更加长。可以在怀疑缓存导致错误时使用。
--force-dll-dependency-cache-update：
用于更新依赖性缓存。这将导致创建分发文件夹的时间更加长。可以在怀疑缓存导致错误或已知需要更新缓存时使用。

3.7 编译器选择

--clang：
强制使用 clang。在 Windows 上，这需要一个 Visual Studio 版本来支持。默认关闭。
--mingw64：
在 Windows 上强制使用 MinGW64。默认关闭。
--msvc=MSVC：
在 Windows 上强制使用特定的 MSVC 版本。默认为最新版本。
-j N, --jobs=N：
指定允许的并发 C 编译器的作业数量。默认为系统 CPU 的个数。
--lto：
如果可用，请使用链接时间优化（GCC 4.6 及更高版本 ）。默认关闭。

3.8 跟踪特性

--show-scons：
在非安静模式下操作 Scons，显示执行的命令。默认关闭。
--show-progress：
提供进度信息和统计数据。默认关闭。
--show-memory：
提供内存信息和统计数据。默认关闭。
--show-modules：
提供包含模块的最终汇总信息。默认关闭。
--verbose：
输出所采取操作的详细信息，特别是在优化中。默认关闭。

3.9 windows 特定控制

--windows-dependency-tool=DEPENDENCY_TOOL：
在为 Windows 编译时，使用此依赖性工具。默认为 depends.exe 文件，其他允许的值为 pefile。
--windows-disable-console：
在为 Windows 编辑时，禁用控制台窗口。默认关闭。
--windows-icon=ICON_PATH：
添加可执行文件的图标（只有 Windows 下）

3.10 插件控制

--plugin-enable=PLUGINS_ENABLED, --enable-plugin=PLUGINS_ENABLED：
启用插件。必须指定插件名。使用 --plugin-list 查询所有的插件列表并退出。默认为空。
--plugin-disable=PLUGINS_DISABLED, --disable-plugin=PLUGINS_DISABLED：
禁用插件。必须指定插件名。
--plugin-no-detection：
插件会检测是否可以使用他们。使用此选项可以禁用插件发出的警告。默认关闭。
--plugin-list：
显示所有可用的插件并退出。
--user-plugin=USER_PLUGINS：
用户插件的文件名，可以指定多次。默认为空。

 3.11 打包控制

--follow-stdlib, --recurse-stdlib
                    Also descend into imported modules from standard
                    library. This will increase the compilation time by a
                    lot. Defaults to off.
--nofollow-imports, --recurse-none
                    When --recurse-none is used, do not descend into any
                    imported modules at all, overrides all other recursion
                    options. Defaults to off.
--follow-imports, --recurse-all
                    When --recurse-all is used, attempt to descend into
                    all imported modules. Defaults to off.
--follow-import-to=MODULE/PACKAGE, --recurse-to=MODULE/PACKAGE
                    Recurse to that module, or if a package, to the whole
                    package. Can be given multiple times. Default empty.
--nofollow-import-to=MODULE/PACKAGE, --recurse-not-to=MODULE/PACKAGE
                    Do not recurse to that module name, or if a package
                    name, to the whole package in any case, overrides all
                    other options. Can be given multiple times. Default
                    empty.

一：conda-pcak在什么情况下使用：

二：conda常见的使用指令：

1：查看自己conda管理有几种python环境：

2：创建一个新的python环境：

3：对已经存在的python环境进行复制：

4：切换到对应的python环境：

三：打包某个python环境

1：进行python环境打包：

2：传输这个压缩文件py3666.tar.gz到你所需要的服务器上：

3：解压缩py366.tar.gz:

4：激活环境：

特别强调的问题：

一：conda-pcak在什么情况下使用：

移植python环境一般用于一下几种情况：

        1：别人要运行你的代码，但是没有你的python环境，如果要一个一个python包进行安装，则非常麻烦，并且有时候还安装出现问题。

        2：有一个包始终安装不上，但是在你的另一个python环境下有，或者在别人的环境中存在，这个时候就可以将python环境打包，移植到你的电脑上，然后激活该环境，运行对应的项目。

        在我初期学习时，总是有包安装不上，或者就是不通的项目需要不通的环境，但是也总不能在一个环境下运行所有项目，这里面牵扯到python版本和各种包的版本的问题，是在令人头疼，耐心看完这篇文章，你会对python环境的管理有一个熟练且清楚的掌握。

二：conda常见的使用指令：

1：查看自己conda管理有几种python环境：

conda info –envs

可以看到，我的服务器下conda管理了3个环境（base, py3.8, py36）

2：创建一个新的python环境：

conda create -n py3.8 python=3.8

Py3.8是新创建的python环境的名字，python=3.8是环境的版本

3：对已经存在的python环境进行复制：

conda create -n py3.8_0 –clone py3.8

Py3.8_0是复制后的python环境的名字，py3.8是需要复制的python环境的名字

4：切换到对应的python环境：

conda activate base

可以看到， 我之前是在py3.8python环境中，现在切换到了base环境中。

三：打包某个python环境

在打包之前如果没有conda-pack包的话，需要安装pip install conda-pack

1：进行python环境打包：

conda pack -n py36 -o py366.tar.gz

Py36是需要打包的已存在的python环境，py366.tar.gz是我们打包后压缩包的名称

可以看到我们将py36打包，然后当前目录下出现了一个py366.tar.gz的压缩包

2：传输这个压缩文件py3666.tar.gz到你所需要的服务器上：

        这里我是有两台linux服务器，我自己使用的是windows平台，使用xftp先从第一个服务器上把压缩包传输到windows上，然后再传输到另一个服务器的anaconda下的envs目录下，也就是/root/software/anaconda3/envs。

3：解压缩py366.tar.gz:

        创建文件：py366，因为我们是要将压缩文件解压到py3666中，这个创建的名字到时候就是你的虚拟python环境的名字。

mkdir py366

解压缩：

tar -zxvf py366.tar.gz -C py366

4：激活环境：

conda activate py366

可以看到此时我们anaconda3/envs目录下的文件。

特别强调的问题：

        这种python环境打包，只能在通一种操作系统中进行，比如你在windows平台上安装的anaconoda，打包anaconda中的python环境到linux服务器中，这样的是用不了的，我之前不知道，进行了这样的尝试，还以为出现了错误，我们可以看下面图片就明白了。

        左边的是windows下的anaconda/envs下的py36环境下的文件，而右边是linux下的anaconda3/envs下的py37环境下的文件，可以看到两个是不一样的，这也就说明了两种系统的python环境是不能这样操作的。

前言

一个Python项目的完成后需要发布，这就涉及到打包和部署。项目可打包成可执行的exe程序，或者打包成可通过命令安装启动的安装包。其中打包成可执行文件工具用的最多的是pyinstaller，该工具支持windows和linux。而打包成安装包可以是setuptools来安装，或者使用buildout进行构建。而部署可以是直接部署，也可以是docker容器化部署，相比直接部署docker部署方式会省去一堆环境的配置，且轻量，启动快。文章主要以buildout打包方式，和docker部署方式来实践

一、项目打包

1.1.项目结构

这里的案例是一个简单的python的web项目，先来看下项目的包文件结构

alone-server/
├── common
│  ├── conf.txt
│  ├── config.py
│  ├── logger.py
│  ├── md5.py
│  └── mysql_connector.py
├── logs
└── app.py

1.2.本地打包Python项目依赖

在idea中的项目根目录打开Terminal，执行以下命令（前提已经配置好python环境），会在根目录下生成requirements.txt依赖文件

pip freeze > requirements.txt

二、发布Linux上

2.1.部署方式

2.1.1.直接部署

文章主要介绍docker方式部署，所以直接部署方式这里就简单概括下主要步骤

1.服务器上安装配置好python相关环境（这里就不展开了，可以参考网上方式）
2.压缩项目源码为zip包，使用xshell+xftp方式上传到服务器
3.服务器上解压缩包，cd进项目根目录，执行以下命令安装依赖，执行命令可以看到正在下载文件中的各个依赖，需要一定时间

pip install -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com -r requirements.txt

4.运行项目启动文件，执行以下命令，执行项目入口文件，我这里的入口文件为app.py，启动后就部署成功了，web可以进行访问了

python app.py 

2.1.2.Docker部署

docker容器化部署需要一些准备工作，如服务器安装Docker，项目配置Dockerfile文件等

2.1.2.1.Linux安装Docker

这里使用的是CentOS7系统。在系统中安装Docker可以安装系统中CentOS-Rxtras库中已自带有Docker（但不是最新版本，版本为1.13）,也可以安装指定版本，或者安装最新的版本，由于前期自己测试中发现自带得到Docker版本过低会带来一定问题，后期为了处理还作升级比较麻烦，所以采用的是指定版本安装。以下是三种安装方式：

方式1：使用CentOS-Rxtras库中已自带有Docker直接安装

yum install docker

方式2：安装最新版本
（1）安装基础工具

yum -y install yum-utils device-mapper-persistent-data lvm2

（2）配置yum镜像库

yum-config-manager --add-repo http://mirrors.163.com/.help/CentOS7-Base-163.repo
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

（3）安装最新版本

yum install docker-ce

方式3：指定版本安装

（1）安装基础工具

yum -y install yum-utils device-mapper-persistent-data lvm2

（2）配置yum镜像库

yum-config-manager --add-repo http://mirrors.163.com/.help/CentOS7-Base-163.repo
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

（3）查看可安装版本信息

yum makecache fast

yum list docker-ce.x86_64 --showduplicates | sort -r

（4）安装指定版本

yum install docker-ce-19.03.13 -y

上述安装后，查看版本信息确认安装成功，并设置开机自启动

docker -v

systemctl start docker
systemctl enable docker

2.1.2.2.创建Dockerfile

一个docker容器的运行基础是镜像，实际上镜像就是代码与运行环境打包生成的。docker创建镜像有三种方式，分别是基于已有容器创建、基于本地模板创建、dockerfIile创建，这里就不一一赘述每种方式了，我采用的是dockerfile创建方式。

在项目根目录创建Dockerfile，编写执行脚本

# 设置基础镜像
FROM python:3.7
# 设置代码文件夹工作目录 /app
WORKDIR /app
# 复制当前代码文件到容器中 /app
ADD . /app
# 设置时间
RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
# 安装所需的包，这里的requirements文件名需和项目生成的一致
RUN pip install --trusted-host mirrors.tuna.tsinghua.edu.cn -r requirements.txt -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple/
# 执行入口文件
CMD ["python", "app.py"]

2.1.2.3.压缩打包上传

（1）本地压缩打包后缀名为.zip包

（2）上传服务器
使用xhell+xftp（或其他工具）将包上传到指定目录

（3）解压缩
cd 进入文件上传路径，执行解压缩命令，unzip 包名。这里需要系统已经安装了unzip，如未安装会出现-bash: unzip: command not found的错误，只要执行命令： yum install -y unzip zip 进行安装就可以了

unzip alone-server.zip

2.1.2.4.生成镜像

cd进项目根目录，app.py启动文件需要同Dockerfile放置在同一目录下，执行以下命令生成镜像，注意命令后的 ‘.’ 符号指的是在当前目录下执行创建，不要遗漏了该符号。创建会去执行下载基础镜像和各个依赖，需要等待一定时间。

docker build -t 镜像名称 .

2.1.2.5.启动容器

在我的项目中启动的端口是5002，在启动容器时候把该端口映射到9001，这样我们就可以通过该端口访问项目了

docker run --name 容器名称 -d -p 9001:5002 镜像名称

通过ip和端口访问测试的接口，成功返回

另外，还可以通过以下几个命令保存镜像或者导入镜像，进入容器，退出容器等

docker save 容器id > 路径文件名

导入本地镜像

docker load -i 文件名.tar

进入容器

docker exec -it 容器名 /bin/bash

退出容器

exit