基于Rainbond开发Python云原生应用

组件开发

这里使用 基于源码中的 Dockerfile 创建组件，因为这种方式能兼容所有类型的项目。

识别为 Dockerfile 类型的源码将使用类似于 docker build -t xxx/xxx . 的命令进行镜像构建，因此此方式是灵活性最高的源码编译方式

基本结构

Python 云原生应用的基本目录结构如下，由 app.py（主程序）、Dockerfile（容器配置）和 requirements.txt（依赖关系）三个文件组成。

.
├── app.py
├── Dockerfile
├── requirements.txt

app.py

最简单、且符合 RESTful 的 Python Flask 主程序如下：

import json
from flask import Flask, request
from rainbond_python.parameter import Parameter
from rainbond_python.error_handler import error_handler

app = Flask(__name__)
error_handler(app)

@app.route('/demo/1.0/api', methods=['GET', 'POST', 'PUT', 'DELETE'])
def api():
    parameter = Parameter(request)

    if parameter.method == 'GET':
        return json.dumps(parameter.param_url, ensure_ascii=False), 200, []

    elif parameter.method == 'POST':
        return json.dumps(parameter.param_json, ensure_ascii=False), 200, []

    elif parameter.method == 'PUT':
        return json.dumps(parameter.param_json, ensure_ascii=False), 200, []

    elif parameter.method == 'DELETE':
        return json.dumps(parameter.param_json, ensure_ascii=False), 200, []

if __name__ == '__main__':
    app.run(host='0.0.0.0', debug=True)

requirements.txt

这个通用的 Python 项目的依赖文件，根据上面的示例代码，我们的依赖如下：

Flask
gunicorn
rainbond-python

Dockerfile

这个通用的 Dockerfile 是用来构建镜像的文本文件，内容包含了一条条构建 Docker 镜像所需的指令，基于上面的示例代码，我们的容器配置如下：

FROM python:3.8.7
WORKDIR /app
ADD . /app
RUN pip install -i https://mirrors.aliyun.com/pypi/simple/ --no-cache-dir -r requirements.txt
CMD ["gunicorn", "app:app", "-b", "0.0.0.0:8000", "--log-file", "-", "--access-logfile", "-", "--error-logfile", "-"]
EXPOSE 8000

组件调试

在不同的阶段（开发、测试、发布）中，我们可以使用不同的方式对组件进行调试，这些调试可以确保组件在 Rainbond 云原生平台上被正确部署。

# 开发调试
$ python3 app.py
# 测试调试
$ pip3 install -r requirements.txt
$ gunicorn app:app
# 发布调试
$ docker build -t devdocker .
$ docker run devdocker

部署组件

首先创建好 团队 和 应用，并进入到应用视图中，选择 “+ 添加组件”，如下图：

使用源码添加组件.png

点击 “自定义仓库”，填入 Git 仓库地址，如果组件是统一管理在同一个仓库中，我们可以通过 “填写子目录路径” 来指定组件所在目录，如下图：

填写Git仓库地址.png

最后点击 “新建组件” 就可以快速开始部署组件。

组件访问策略

在组件需要 被外部访问 时，如果是企业内网部署，我们还需要配置组件的访问策略，进入应用视图中，选择 “网关 > 访问策略管理” ，如下图：

访问策略管理.png

找到我们刚才创建的组件，点击 “编辑”，并按照什么示例代码的内容进行配置，如下图：

编辑Http访问策略.png

特别要注意，“域名” 要填写一个配置好内网解析的域名地址，这样，便可以通过 xxxxxx.xxxx.com/demo/1.0/api 访问到组件的服务。

数据存储

在 Python 云原生开发实践中，推荐使用 MongoDB 数据库，因此我们可以从 Docker Hub 获取 MongoDB Docker 镜像。

添加存储组件

首先进入到应用视图中，选择 “+ 添加组件”，并选择 “从源镜像开始 > 指定镜像”，然后在 “镜像地址” 栏输入 mongo，如下图：

添加存储组件.png

点击创建，接下来 Rainbond 就会开始自动部署 MongoDB 存储组件。（PS：如果在内网环境下，请耐心等待……）

配置存储组件

首先，我们要明确我们是在开发 云原生 项目，数据库是可选项，所以，就算没有这个可选项，我们的组件也不能因为这个异常，而导致程序崩溃。

在云原生的体系中，数据库是一个独立的组件，是原生运行在容器云平台里的一个分布式数据库，真正做到了存储和计算的完全分离

在 MongoDB 组件的 依赖 > 端口列表 中找到 27017 端口，开放 “对内服务”，修改 “使用别名” 为 MONGODB，如下图：

编辑MongoDB别名.png

通过上一步，就可以在 依赖 > 组件连接信息 中看到 MONGODB_HOST 和 MONGODB_PORT 两个变量，分别是 MongoDB 组件的连接地址和端口号信息。

依赖存储组件

在 计算组件 和 存储组件 分离的情况下，计算组件 需要通过 存储组件 的 依赖 > 组件连接信息 中的数据库连接信息来访问 存储组件。

在 计算组件 视图的的 依赖 > 依赖组件信息 下，选择 “+ 添加依赖”，并添加我们安装在应用内的 存储组件，如图所示：

依赖存储组件.png

接下来，我们就可以在 计算组件 中，通过环境变量，获取 存储组件 的组件连接信息。

操作数据库

在 计算组件 的 app.py（主程序）文件中，可以简单实现一个对 MongoDB 数据库的读取、写入的示例：

import json
from flask import Flask, request
from rainbond_python.parameter import Parameter
from rainbond_python.db_connect import DBConnect

app = Flask(__name__)
db = DBConnect(db='demo', collection='test')

@app.route('/demo/1.0/api', methods=['GET', 'POST'])
def api():
    parameter = Parameter(request)

    if parameter.method == 'GET':
        cursor = db.mongo_collection.find()
        if not db.mongo_collection.estimated_document_count():
            return '资源为空', 204, []
        data = list(cursor)
        return str(data), 200, []

    elif parameter.method == 'POST':
        if parameter.verification(checking=parameter.param_json, verify={'name': str, 'age': int}):
            param = parameter.param_json
            insert_dict = {'name': param['name'], 'age': param['age']}
            if db.write_one_docu(docu=insert_dict):
                return '新资源被创建', 201, []
            else:
                return '资源无法被创建', 500, []
        else:
            return '请求参数错误', 400, []

if __name__ == '__main__':
    app.run(host='0.0.0.0', debug=True)

上面代码中，并没有出现获取 存储组件 连接信息的代码，因为这部分内容已经被 rainbond-python 所封装，其中 DBConnect 的初始化代码片段如下：

import os
……
class DBConnect():
    def __init__(self, db: str, collection: str, home_kye='MONGODB_HOST', port_kye='MONGODB_PORT'):
        self.mongo_home = os.environ.get(home_kye, None)
        self.mongo_port = os.environ.get(port_kye, 27017)
……

可以看到，home_kye 和 port_kye 的默认值对应的正是 MONGODB_HOST 和 MONGODB_PORT，当我们没有赋值时，它自动会读取这两个环境变量。

开发细节

在环境中存储配置

按照 12-factors 的第 III 条：在环境中存储配置。我们需要把组件的配置信息存储在环境中，在 Dockerfile（容器配置）文件中，我们添加两个配置信息：

……
ENV SPEECH_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
ENV SERVICE_REGION=eastus
……

这样配置后，当组件部署到 Rainbond 云原生平台后，这两个环境配置会出现到组件视图的 “环境配置” 标签页，如下图所示：

在环境中存储配置.png

然后我们只需要在组件的代码文件中，通过下列代码，即可读取到这些配置信息：

import os
……
speech_key = os.environ.get('SPEECH_KEY', None)
service_region = os.environ.get('SERVICE_REGION', None)
……

容器中安装依赖

有时候，默认的 Docker 容器里会缺少组件运行必须的依赖，这时我们就需要配置安装命令，例如，我们在 Dockerfile（容器配置）文件里编写系统库 libasound2 的安装命令：

……
RUN apt-get update
RUN apt-get install -y libasound2
……

这样，我们就可以缺啥补啥。

在开发机上配置环境变量

在本地开发时，我们就需要在开发机配置组件需要的环境变量，以 Ubuntu 开发机为例，通过 vim /etc/profile 打开系统环境变量文件，并在最后加入新的环境变量，例如：

export KEY=VALUE

然后保存文件，并通过 source /etc/profile 使编辑的配置生效，还可以通过 export 查看当前系统的环境变量，再确认一遍环境变量添加成功。

前端组件的打包脚本

如果是 React 前端项目，那么 Dockerfile（容器配置）文件可以参考下面代码：

FROM node:lts
WORKDIR /app
ADD . /app
RUN npm install
RUN npm run build
RUN npm install -g http-server
CMD ["http-server", "./build", "-p", "6001", "-a"]
EXPOSE 6001

大致过程是：安装Node稳定镜像 > 初始化项目 > 构建项目 > 安装http-server库 > 运行项目，很简单的。

查看组件容器日志

如果要查看 Rainbond 部署的组件日志，我们要知道 K8s 与 Rainbond 的关系：NAMESPACE=团队/集群、POD=应用、Docker=组件。所以，我们要查看日志的时候，基本就是查看K8s日志的路数：

# 登录集群主节点服务器
ssh -p22 xxxx@xxx.xxx.x.xxx
# 查看POD
kubectl get pod -A -o wide
# 查看某一个POD中容器的日志（一）
kubectl -n [NAMESPACE] logs --tail=100 [POD] [Docker]
# 查看某一个POD中容器的日志（二）
kubectl -n [NAMESPACE] logs -f [POD] [Docker]

其中，NAMESPACE 和 POD 的位置在下图位置中：

命令空间与POD.png

而 Docker 则在 Rainbond 上查看，如下图：

Rainbond中的容器ID.png

这样就可以直接查看最原始的日志信息。

处理前端组件跨域问题

我们可以把 API 服务组件、前端 UI 组件通过同一个域名进行解析，如下图：

根本上解决跨域问题.png

这样，哪里还会出现什么跨域问题。

提前构建好基础镜像

如果构建过程太慢，比如构建一次要好几分钟，那么我们可以提前把一些环境构建过程制作成基础镜像，只要构建过程会加快很多。

# 本地构建镜像
$ docker build -t demo .
# 给镜像打tag
$ docker tag [IMAGE ID] [私有hub域名]/[项目名称]/demo:latest
# 推送到私有hub仓库
$ docker push [私有hub域名]/[项目名称]/demo:latest

然后将 Dockerfile（容器配置）文件的第一行改为：

FROM [私有hub域名]/[项目名称]/demo:latest

这样，原本可能要几分钟的构建过程，现在只需要几十秒就可以完成，非常棒！

模拟服务器环境调试

在云原生平台部署组件之前，最好模拟服务器环境在本地测试一下：

# 本地构建镜像
$ docker build -t demo .
# 查看打包的镜像
$ docker images
# 运行镜像
$ docker run -p 6008:6008 demo
# 运行镜像（指定环境变量）
$ docker run -e "KEY=xxx" -p 6008:6008 demo
# 运行镜像（后台运行）
$ docker run -d -p 6008:6008 demo
# 查看运行中的容器
$ docker ps
# 暂停运行中的容器
$ docker stop <CONTAINER ID>
# 关闭运行中的容器
$ docker rm <CONTAINER ID>
# 删除镜像
$ docker rmi <IMAGE ID>

这样可以避免在云原生平台不方便调试的问题。

查看网关容器Nginx配置

在 Rainbond 平台配置网关后，可以进入网关容器，查看配置的域名规则生成的 Nginx 配置是否正确：

# 找到网关容器的NAME
$ kubectl get pod -A -o wide
# 进入网关容器
$ kubectl -n rbd-system exec -it <网关容器NAME> bash
# 输出default_servers.conf内容
$ cat /run/nginx/conf/http/default/default_servers.conf
# 退出网关容器
$ exit

这样就可以确认 Rainbond 平台配置的网关规则是否正确。