jenkins其实自带分布式特性，是Master/Slave模型。在Master上分配任务，然后在slave或者Master完成。这个特性带来两个好处：
* 能够有效分担主节点的压力，加速构建速度
* 能够指定特定的任务在特定的主机上进行



# 使用场景
1. 如果项目需要定期集成，同时每次集成都需要较长时间。如果都运行在master服务器上，会消耗过多资源，这时就需要在建立多台设备，并配置为slave机器来为master提供负载服务
2. 需要不同的环境集成。如一个项目，包含Web端，包含Android端，包含IOS端，不同的测试需要的环境都不同，此时可以为每个环境配置一个slave测试。
3. 一个slave是一台为主的jenkins机器建立一个负载build项目的电脑，一旦建立这个分布式任务是完全自动化的。每个slave运行一个单独的程序，不需要再一个slave安装全部的jenkins


Master的职责：
负责调度任务和发送请求
Slave的职责：
多个Salve可以并发的执行并构建任务，或者用于分布式的自动化测试，当自动化测试代码非常多或者而是需要在多个浏览器上并行的时候，可以把测试代码分到不同节点上运行，从而加速自动化测试的运行。

流程：
1. Master——Slave（管理节点，分配任务）
2. Salve(向master注册，反馈状态：空闲/忙碌,反馈任务进度，反馈任务结果)


Jenkins分布式环境搭建步骤如下：
1. master节点上安装和配置jenkins
2. master节点上新增Salve节点配置，生成master-slave通讯文件SlaveAgent
3. Slave节点上运行SlaveAgent，通过SlaveAgent实现和Master节点的通讯
4. Master节点上管理Jenkins项目，指定Salve调度策略，实现Slave节点的任务分配和结果搜集
5. Master节点上安装和配置Jenkins

jenkins分布式构建

# 部署上线
> 什么是部署？
部署指的是把程序托管到拥有公网ip的远程服务器(计算机)上，这样程序可才可以被互联网上的所有人通过IP或映射到IP的域名访问到



# 传统部署VS云部署VS静态部署
* 传统部署
    1. 类似于毛胚房，需要自己动手设置所有环境
    2. 通常会通过虚拟主机服务提供商来租用虚拟主机，这些服务被成为IaaS（设施即服务）。主流的有Amazon Ec2、阿里云云的ECS
    3. 传统部署比较灵活，一切都由你自己来掌控，不过同时需要耗费较多的经历去进行环境搭设和维护，需要运维人员来维护。
    4. 如果不想把时间都花费到运维上，只想尽快让你的程序部署上线，可以考虑使用云部署
* 云部署
    1. 精装修的公寓，程序只需要接通电源就可以运行
    2. 云部署即Pass（平台即服务）。简单来说，云部署服务提供了一个完善的平台，提供了所有底层基础设施，我们只需要推送程序代码即可。
    3. 使用云部署，可以省去配置服务器、设置数据库、配置网络服务器以及设置防火墙等步骤。使用简单的方式即可集成第三方工具、添加数据库、设置邮件服务等，使用起来非常灵活
    4. 例如paas的有HeroKu PythonAnywhere，Webfaction,Goolge App Engine等。普通人推荐HeroKu
    
* 静态部署
    1. 静态部署是先借助工具将程序静态化处理，比如使用扩展Frozen-Flask,静态处理就是把程序中的所有动态页面全部转换成对应的HTML文件，分目录放置。
    2. 静态处理后的程序部署成本非常低，而且有大量免费的静态部署服务，比如Github Pages\Netlify等
    3. 一般适用于不需要接受用户输入、不产生动态输出的程序，比如个人博客
    


# 1. 基本部署流程
如果你将程序代码托管在在线代码托管平台比如Github\BitBucket\Gitlab等，那么使用Git部署程序的过程非常简单，和在你自己的电脑上运行程序的基本相同，大致流程如下：
    
    * 在本地执行测试
    * 将文件添加到Git仓库并提交（git add & git commit）
    * 在本地将代码推送到代码托管平台(git push)
    *　在远程主机上从代码通过平台复制程序仓库　git clone
    * 创建虚拟环境并安装依赖
    * 创建实例文件夹，添加部署特定的配置文件或是创建.env文件存储环境变量并导入。
    * 初始化程序和数据库，创建迁移环境
    * 使用Web服务器运行程序

##　1.1 更新程序步骤
    
    * 在本地执行测试
    * 将文件添加到Git仓库并提交  git add & git commit
    * 在本地将代码推送到代码托管平台 git push
    * 在远程文件上从代码托管平台拉去程序仓库 git pull
    * 如果有依赖变动，或是数据库表结构变动，那么执行依赖安装和数据库迁移操作
    * 重启Web服务器

# 2. 部署前的准备
##　2.1 更新程序配置
* .env文件。不同的环境需要不同的配置，将某些包含敏感信息的配置变量优先从环境变量获取，比如数据库URL、Email服务器配置信息等。将这些关键信息填写到.env文件中。记得将文件放到.gitignore中
* SECRET_KEY 。我们需要要为保存程序密钥的SECRET_KEY配置变量生成一个随机字符，更换开发时填入的占位字符。
  ```python
  # 随机密钥的生成方式有很多。比如，os模块的urandom()方法可以用来生成随机密码
  import os
  os.urandom((12))
  # 如果使用python3.6，可以使用secrets模块提供的token_bytes()、token_hex()、token_urlsafe()方法
  import secrets
  token_urlsafe(16)
  # 或者使用uuid
  ```
* 如果需要执行flask相关的命令，需要配置.flaskenv的文件



在PythonAnywhere部署程序时，因为PythonAnywhere使用的数据库服务会在5分钟断开连接，需要将flask_sqlalchemy提供SQLALCHEMY_POOL_RECYCLE配置变量的值设为300一下，用来设置数据库连接池的回收时间，比如:
```shell
SQLALCHEMY_POOL_RECYCLE=280
```
# 3. 创建生产环境专用的程序
##　3.1 设置迁移工具
详情查看[5数据库](./5数据库.md)

##　3.2 程序日志
1. 将日志写入到文件中
```python
import logging
from logging.handlers import RotatingFileHandler
def create_app(config_name=None):
  register_logger(app)
  
def register_logger():
    app.logger.setLevel(loggging.INFO)
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    file_handler = RotatingFileHandler('logs/bluelog.log',maxBytes=10*1024*1024,backupCount=10)
    file_handler.setFormatter(formatter)
    file_handler.setLevel(logging.INFO)

    if not app.debug:
        app.logger.addHandler()
```
> 代码解释：
> * 为了让日志记录器记录INFO等级的日志时间，我们首先将app.logger的等级设为INFO。
> * 然后创建一个logging.Formatter对象设置日志的输出格式。
> * 为避免日积月累产生一个巨大的日志文件，我们使用RotatingFileHandler类（从logging.handlers模块导入）创建一个轮转文件类型的日志处理器，实例化这个类传入日志文件目标路径、最大文件尺寸和备份数量。
> * 当日志文件的大小超过实例化传入的maxBytes参数设定的值时（单位为字节byte，我们这里设为10MB），它会循环覆盖之前的记录
> * 将backupCount参数设为10次，会依次创建10个日志文件，10个文件全部存满10MB后会开始覆盖之前的文件；
> * TimeRotatingFileHandler类，它会根据设定的时间间隔（通过实例化传入参数设定）来定期覆盖日志数据


### 日志不需要传入到Git仓库中的方法？
* 在项目根目录下创建一个logs文件夹
* 在logs目录下文件一个.gitkeep文件，并在.gitignore中写入一个*.log规则，这会确保将logs目录添加到Git仓库，但是忽略所有以.log结尾的日志文件


2. 云部署平台的日志
云部署平台会从stdout（标准输出）和stderr(标准错误输出)收集日志，如果要吧程序部署到云平台上，需要创建一个StreamHanler类型的日志处理器来替代上面的RotatingFileHandler处理器
   
3. 通过邮件发送关键日志
在生产环境重，低等级的信息可以记录到日志文件重，而关键的信息（比如Error等级以上）则需要通过邮件发送给管理员，以便及时休闲服问题
   
为了在日志信息重插入出发这个日志事件的请求信息，我们创建一个自定义的RequestFormatter类，它继承自logging.Formatter类，添加了几个自定义字段来插入请求信息。

```python
import requests
import logging


def register_logger():
  class RequestFormatter(logging.Formatter):
    def format(self, record):
        record.url = requests.url
        record.remote_addr = request.remote_addr
        return super(RequestFormatter,self).format(record)
  request_formatter = RequestFormatter(
    '[%(asctime)s] %(remote_addr)s requested %(url)s \n %(levelname)s in %(module)s: %(message)s' 
  )
```
使用SMTPHandler类可以创建一个SMTP处理器，传入的参数太多从相应的Flask-Mail配置变量获取。我们将这个邮件日志处理器的等级设为logging.ERROR,当发生Error等级及以上的日志事件时会将日志通过邮件发送给管理员
```python
import os
import logging
from logging.handlers import SMTPHandler

def register_logger():
    mail_handler = SMTPHandler(
      mailhost=os.getenv('MAIL_SERVER'),
      fromaddr=os.getenv('MAIL_USERNAME'),
      toaddrs=os.getenv('BLUELOG_ADMIN_EMAIL'),
      subject='Application Error',
      credentials=(os.getenv('MAIL_USERNAME'),os.getenv('MAIL_PASSWORD'))
    )
    mail_handler.setLevel(logging.ERROR)
    mail_handler.setFormatter(request_formatter)

    if not app.debug:
        app.logger.addHandler(mail_handler)
```

除了传统的日志记录，我们还可以使用第三方错误追踪工具来处理程序中的错误。流行的选择是Sentry，当在程序中集成Sentry后，它可以在程序出现异常时通过我们设置的各种方式发送提醒（除了邮件，还可以集成Slack、Whatsapp、IRC等第三方工具）

更重要的是，我们可以在的控制面板中查看关于这个异常的相关代码、上下文变量的值、函数调用堆栈、以及异常触发的次数、涉及的客户端信息等一系列数据，这能够帮助我们及时找出问题的根源并解决问题。

[Sentry更多学习连接](https://juejin.cn/post/6844904143090352135)

[Sentry掘金博客连接](https://zhuanlan.zhihu.com/p/210765546)

# 4. 部署到Linux服务器
准备：
* 远程主机
* 购买一个域名
* 域名解析

## 4.1 登录远程主机，安装基本库和工具
## 4.2 安全防护措施
## 4.3 推送代码并初始化程序环境
## 4.4 使用gunicorn运行程序
## 4.5 使用nginx提供反向代理
## 4.6 使用Supervisor管理进程
我们直接通过命令来运行gunicorn,这并不十分可靠。我们需要一个工具来自动在后台运行它，同时监控它的运行状况，并在系统出错或是重启时自动重启程序。
在/etc/supervisor.d/创建wiki.ini **视个人情况，创建配置文件**
```shell
[program:eric_web]
command=pipenv run gunicorn -w 2 -b 127.0.0.1:5001 wsgi:app --preload  # 需要执行的命令
directory=/root/program/EricWeb #命令执行的目录
environment =PYTHONPATH="$PYTHONPATH:/root/.local/share/virtualenvs/EricWeb-qMyTWs2e/bin" #环境变量
user=root #用户
stopsignal=INT
autostart=true #是否自启动
autorestart=true #是否自动重启
startsecs=60 #自动重启时间间隔（s）
stderr_logfile=/var/log/eric_web/webs.err.log #错误日志文件
stdout_logfile=/var/log/eric_web/webs.out.log #输出日志文件

```
重启
```shell
supervisorctl reload
```
除了命令行工具supervisorctl,Supervisor还提供了Web客户端，你可以通过在/etc/supervisor/supervisord.conf中写入下面的配置来开启：
````shell
[inet_http_server]         ; inet (TCP) server disabled by default
port=*:9001        ; (ip_address:port specifier, *:port for all iface)
username=yourname              ; (default is no username (open server))
password=yourpassword
````
> ; 后边的语法代表注释

# 5. 更新部署后的程序
不过，尽量避免这种方式，先在测试环境测试ok了之后，再提交到生产环境中
1. 在本地更新代码
2. 通过生成虚拟数据再浏览器中手动调试
3. 调试满意后执行一系列测试
4. 测试通过后将代码推送到代码托管平台，触发持续集成服务器进行测试
5. 登录远程主机，使用git pull命令拉取更新
6. 执行必要的操作，比如更新数据库结构，安装新的依赖等。
7. 重新启动gunicorn


# 6. 在PythonAnywhere和HeroKu部署
都是国外的，而且基于Amazon来实现的，有一定的延迟，不适合国内生产。

部署上线

# 1. 聊天头像-Gravatar
Gravatar提供的头像文件通过下面形式的URL获取：
```shell
https://gravatar.com/avatar/<HASH>
```



Gravatar使用电子邮件地址获取对应的用户头像，为了防止泄露用户的电子邮件地址，Gravatar采用通过MD5加密的邮件地址，上面的URL中的HASH部分就是电子邮箱的散列值。

为了降低服务器的负载，我们把用户Email地址的MD5散列值存储在数据库email_hash中。

## 1.1 第一个参数：d
地址：https://gravatar.com/avatar/<HASH>?d=monsterid
Gravatar支持的默认头像类别如下表:

| 类别  | 描述  |
| ------------ | ------------ |
| 404  |如果Email散列值没有对应的图片，那么返回HTTP404响应   |
|  mm | mm代表mystery-man(神秘人)，一个在灰色背景下的卡通风格人形边框  |
| identicon  | 基于Email散列值生成的集合形状  |
| monsterid  | 基于Email散列值生成的可爱小怪兽  |
| wavatar  | 基于Email散列值生成的卡通脸  |
| retro  | 基于Email散列值生成的8位像素风格的脸  |
| robohash  | 基于Email散列值生成的机器人  |
| blank   | 一个透明的带有边框的PNG图片  |


## 1.2 第二个参数：
参数s用来设置头像图片的大小，默认的头像图片的大小为80X80.下面的URL将某个头像尺寸设置为100X100:

https://gravatar.com/avatar/Sd3b9f7b7c0328827b57172e4a7abl36?size=lOO

# 2. 使用Flask-socketIO建立实时双向通信

# 2.1 websocket
> 常规轮询、长轮询、websocket的区别？
1. 轮询是传统方式，不存在浏览器兼容性问题，定时的发送网络请求
2. 轮询对客户端的电脑资源会造成额外的开销，如果页面中的定时器过多时不能实时获取最新的数据，获取数据会有延迟。
3. websocket对浏览器的版本有要求，低版本的浏览器不一定能用
3. websocket可以实时获取最新的数据，不会产生额外的开销。服务器有新的数据之后，会主动推送给客户端
4. 轮询是定时的发送的ajax请求，获取服务器的数据
5. 长轮询的方式：客户端向服务器发送请求之后，服务器会暂时把请求挂起，等到有数据更新时再返回最新的数据给客户端，客户端在接收到新的消息后再向服务器发送请求。与常规轮询的不同之处是：数据可以做到实时更新，可以减少不必要的开销



**送命题：选择还是长轮询还是常规轮询**
长轮询是不是总比常规轮询总有优势？我们可以从带宽占有的角度分析，如果一个程序数据更新太过频繁，假设每秒2次更新，如果使用长轮询的话每分钟要发送120次HTTP请求。如果使用常规轮询，每5秒发送一次请求的话，一分钟才20次，从这里常规轮询更有优势。
【长轮询，在请求到数据的时候，会再次请求服务器，服务器没有数据的时候，就挂着】

> websocket的优缺点

**优点**
* Websockets保持一个唯一的连接打开，同时消除长轮询的延迟问题
* Websockets通常不适用XMLHttpRequest，因此，当我们每次需要从服务器获取更多的信息时，无需发送头部数据。反过来，这又减少了数据发送到服务器时需要付出的高昂的数据负载代价
**缺点**
* 当连接终止时候，WebSockets无法自动恢复连接——这是需要你自己实现的部分，也是导致存在许多客户端库的原因
* 早于2011年的浏览器无法支持WebSocket链接
[拓展：SSE](https://www.cnblogs.com/goloving/p/9196066.html)
  
## 2.2 socketIO的介绍
* SocketIo是一个基于JavaScript实现实时通信的开源js库，它可以简化实时Web程序的开发过程
* 支持多种轮询机制以及其他模拟实时通信的方式
* 提供了诸如广播、命名空间、房间、存储客户端数据、异步IO等功能
* 要使用socketIO,客户端和服务端都需要使用Socket.IO框架。
> flask服务端使用flask_socketio，客户端使用socket.io.min.js

聊天室

# 通过设置钩子实现部署自动化
> 借助Git提供的服务器端钩子(server-Side Hooks),比如post-revive钩子，我们可以实现部署操作的自动化。通过定义钩子出发的脚本，我们可以让远程主机的git服务器在接收到本地的代码推送后自动执行相应的更新和重启Web服务器等操作。如果是使用在线代码托管平台，比如github和BitBucket，需要在项目设置中进行对应的设置。
 


在实际部署中，对于大型程序，或多人写作开发的程序，我们通常会为程序设置持续集成系统，通过设置Git钩子，当有人向远程主机的主分支推送代码后会自动出发CI系统进行构建测试，测试通过后才会将改动集成到程序中。


# jenkins关闭重启的方式
* 关闭jenkins
  
    http://192.168.240.179:8080/exit
* 重启jenkins
  
    http://192.168.240.179:8080/restart
* 重新加载设置

    http://192.168.240.179:8080/reload

通过设置git钩子实现部署自动化

在大型flask的项目中，主要三种常见的项目组织架构:功能架构(自己的博客)、分区式架构和混合式架构。



![image.png](/static/img/0226066f150112aa76e3012cb9882fce.image.webp)
## 功能式架构
在功能式架构中，程序包由各个代表程序组件（功能）的子包组成，比如:
* blueprints(蓝本)
因为程序比较简单，蓝本主要是用来组织路由，所有项目中的蓝本直接在blueprints包下的模块中创建。如果蓝本需要注册更多的处理程序，比如错误处理函数、请求处理函数等。

    1. __init__.py
    2. auth.py
       
        1. __init__.py
        2. views.py
        3. errors.py
    3. dashboard.py
       
        ……
    4. front.py
    
        ……
* forms(表单)
  
    1. __init__.py
    2. auth.py
    3. dashboard.py
    4. front.py
* templates(模板)
  
    1. auth/
    2. front/
    3. dashboard/
    4. base.html
* static (静态文件)  
* models(模型)
* __init__.py

通过为蓝本创建子包还可以支持为蓝本创建独立的templates和static文件夹；

和在单模块中创建蓝本不同，当在子包中创建蓝本时，为了方便其他模块导入蓝本对象，这时蓝本对象在蓝本子包的构造文件中创建。
而且，因为在构造文件中定义，为了把路由、错误处理器、请求处理函数等和蓝本对象关联起来，需要在构造文件中导入这些模块。
```python
from flask import Blueprint
front_bp = Blueprint('front',__name__)
from myapp.blueprints.front import views,errors

```
在路由模块等要使用蓝本对象的地方可以直接导入这里创建的蓝本对象:
```python
from bluelog.blueprints.front import front_bp
```


## 分区式架构
在分区式架构中，程序被按照自身的板块分成不同的子包。myapp使用分区式架构可以分别创建front\auth\dashboard三个子包，这些子包直接在程序包的根目录下床架，子包中使用模块组织不同的程序组件，比如views.py、forms.py
如下:
* dashboard/
    
    * __init__.py
    * views.py
    * forms.py
    templates/
    static/

* front/

    ……
  

## 混合式架构
混合式架构，顾名思义，就是不按照常规分类来组织。比如:采用类似分区架构的子包来组织程序，但各个蓝本公用程序包更目录下的模板文件夹和静态文件夹