Python3 Flask+nginx+Gunicorn部署(下)

继续上一篇文章,在上一篇文章中,我们已经把gunicorn和nginx运行并且安装好了,在这一篇,我们需要进行nginx与gunicorn端口进行绑定

上一篇,我们已经将gunicorn运行起来了

gunicorn -w 4 -b 127.0.0.1:8000 入口文件名:app

nginx操作目录:

/usr/local/nginx/sbin

在/usr/local/nginx/sbin目录下可以进行nginx的重启、重载、停止与启动。

在这里我们进行通过nginx反向代理网站域名与服务器,这里可能说得有些绕口,

通俗点:
就是别人访问我们的网站,是通过nginx反向代理再把访问请求发送到flask服务器上的。

首先我们设置一下nginx的配置文件

cd /usr/local/nginx/conf
vi nginx.conf

然后打开配置文件:

    #gzip  on;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    server {
        listen       80;
        server_name  www.00reso.com;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
           # root   html;
           # index  index.html index.htm;
            proxy_pass http://127.0.0.1:8000;
            access_log /home/admin/api_access.log;
            proxy_read_timeout 60;
            error_log  /home/admin/api_error.log;
        }

主要动的地方:

#gzip  on;
# 1代理的设置吧,这个都是这样设置的
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

# 2绑定的域名
server_name  www.00reso.com;

# 3 监听本服务器的端口,设置log,请求时间等
proxy_pass http://127.0.0.1:8000;
            access_log /home/admin/api_access.log;
            proxy_read_timeout 60;
            error_log  /home/admin/api_error.log;

然后进行保存。

接下来重载一下nginx文件,在/usr/local/nginx/sbin/nginx下
使用命令:

sudo nginx -t

如果看到

1 nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
2 nginx: configuration file /etc/nginx/nginx.conf test is successful

就是代表成功了。

重新启动下nginx

sudo service nginx restart

这里重启nginx的命令可能会行不通,这时候,你用
ps -e aux|grep nginx 把nginx的进程杀掉,

然后在 /usr/local/nginx/sbin目录下再次启动nginx

nginx

如果看到:

[admin@izbp11722iq94py8qx691sz conf]$ ps -e aux|grep nginx
root      2657  0.0  0.0  24952   784 ?        Ss   Jun25   0:00 nginx: master process nginx
nobody    2658  0.0  0.1  25388  1752 ?        S    Jun25   0:00 nginx: worker process
admin    13814  0.0  0.0 112664   968 pts/2    S+   20:59   0:00 grep --color=auto nginx

这个情况,就是启动nginx成功了,

验证

1 使用本地ping

curl localhost:80

如果出现flask index页面的内容,就表示nginx与gunicorn配置成功,
2 远程直接输入www.00reso.com 看是否能进行访问,如果没有出现失败的页面,则访问成功,如果出现失败的页面,则大多是防火墙或80端口关闭了,这里我们需要把防火墙打开。

编辑防火墙白名单

[root@localhost ~]# vim /etc/sysconfig/iptables
增加下面一行代码
-A INPUT -p tcp -m state -- state NEW -m tcp --dport 80 -j ACCEPT
保存退出,重启防火墙
[root@localhost ~]# service iptables restart

未分类

这样就可以进行访问了

目前自己还在探索中,现在在快马加鞭的优化中,

因为flask+nginx+gunicorn部署自己踩过了很多坑,但是从坑中踩过来,差不多就都懂了。还好没放弃~~

Python3 Flask+nginx+Gunicorn部署(上)

这次主要是记录flask在python3 环境结合nginx +gunicorn在服务器上进行项目的部署

(一)运行环境

  • 虚拟机centos7
  • python3 环境
  • nginx
  • gunicorn
  • virtualenv

难点:nginx gunicorn的安装配置

(二)nginx、gunicorn简介

Nginx是一款轻量级的Web 服务器/反向代理服务器及电子邮件(IMAP/POP3)代理服务器,并在一个BSD-like 协议下发行。其特点是占有内存少,并发能力强,事实上nginx的并发能力确实在同类型的网页服务器中表现较好,中国大陆使用nginx网站用户有:百度、京东、新浪、网易、腾讯、淘宝等

gunicorn是一个python Wsgi http server,只支持在Unix系统上运行,来源于Ruby的unicorn项目。Gunicorn使用prefork master-worker模型(在gunicorn中,master被称为arbiter),能够与各种wsgi web框架协作。

(三)软件安装

(1)首先安装gunicorn

直接使用命令:pip install gunicorn

(2) 将gunicorn 加入到app.run()中,

这里我在路径为:/home/flaskproject/flaskweb 下新建一个myweb.py 作为入口函数
代码为:

from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
    return 'hello world'
if __name__ == '__main__':
    from werkzeug.contrib.fixers import ProxyFix
    app.wsgi_app = ProxyFix(app.wsgi_app)
    app.run(

未分类

(3)用命令启动gunicorn

在myweb.py路径下,一定要记住是当前路径下!!
方式一:

gunicorn myweb:app

未分类

python 虚拟环境的安装:

pip install virtualenv 

然后一顿骚操作:

mkdir flaskproject

cd flaskproject

virtualenv flaskprojectenv

然后进行激活:

source flaskprojectenv/bin/activate

正如下图一样的骚操作,之前我也是很少用虚拟环境的,现在感觉虚拟环境并没有那么神秘,因为以前是很拒绝,不会用,不过这次是会用了,

退出虚拟环境的命令是:deactivate(这里我只是说一下)

未分类

这时候我们本地服务器看一下是否运行起来(已经有hello world):

[root@localhost flaskproject]# curl http://127.0.0.1:8000
hello world[root@localhost flaskproject]# 

ctrl + c 停掉当前环境,我们使用第二种方式试一下
专门为处理高并发则要开多个进程和修改监听端口方式:

gunicorn -w 4 -b 127.0.0.1:8000 入口文件名:app

如下代码:

(flaskprojectenv) [admin@localhost flaskweb]$ gunicorn -w 4 -b 127.0.0.1:8000 myweb:app
[2018-05-28 10:57:11 -0400] [1813] [INFO] Starting gunicorn 19.8.1
[2018-05-28 10:57:11 -0400] [1813] [INFO] Listening at: http://127.0.0.1:8000 (1813)
[2018-05-28 10:57:11 -0400] [1813] [INFO] Using worker: sync
[2018-05-28 10:57:11 -0400] [1816] [INFO] Booting worker with pid: 1816
[2018-05-28 10:57:11 -0400] [1817] [INFO] Booting worker with pid: 1817
[2018-05-28 10:57:11 -0400] [1819] [INFO] Booting worker with pid: 1819
[2018-05-28 10:57:11 -0400] [1821] [INFO] Booting worker with pid: 1821

本地服务器已经运行了,但是我们远程并不能进行访问(win10访问虚拟机)

未分类

说明端口号没有打开,这时候我们需要把防火墙,端口号什么的都进行设置一下,可以看一下这篇博客:linux下nginx首次安装远程无法访问

主要是两个命令:

[root@localhost nginx-1.12.1] systemctl stop firewalld
[root@localhost nginx-1.12.1] systemctl stop iptalbes

接下来:我们进行nginx的配置安装与gunicorn的相结合并进行部署。

Python Web 腾讯云部署:flask+fabric+gunicorn+nginx+supervisor

最近看了《Flask Web开发–基于Python的Web应用开发实战》,还有廖雪峰老师的Python教程,前者是基于Web框架flask进行开发,后者是自己搭建了一个Web框架。Web框架致力于如何生成HTML代码,而Web服务器用于处理和响应HTTP请求。Web框架和Web服务器之间的通信,需要一套双方都遵守的接口协议。WSGI协议就是用来统一这两者的接口的。

为了部署一个完整的环境,本文将使用flask作为Web框架,Gunicorn作为WSGI容器,Nginx作为Web服务器,同时使用Supervisor进行进程管理,并使用Fabric实现自动化部署。

前期准备

申请一个腾讯云服务器Ubuntu Server 16.04.1 LTS 64位:

账户:ubuntu
密码:**********
内网ip:172.16.0.17
外网ip:139.199.184.183

使用《Flask Web开发》源码:

$ mkdir web
$ cd web
~/web$ git clone https://github.com/miguelgrinberg/flasky.git

设置并进入虚拟环境:

~/web$ cd flasky
~/web/flasky$ virtualenv venv
~/web/flasky$ source venv/bin/activate

安装对应的库:

(venv) ~/web/flasky$ cd requirements
(venv) ~/flasky/requirements$ pip3 install -r common.txt
(venv) ~/flasky/requirements$ pip3 install -r dev.txt
(venv) ~/flasky/requirements$ pip3 install -r heroku.txt
(venv) ~/flasky/requirements$ pip3 install -r prod.txt

创建数据库:

(venv) ~/flasky/requirements$ cd ..
(venv) ~/flasky/$ python3 manage.py deploy

Fabric

Fabric入门看这里https://www.jianshu.com/p/0be28f6c4607

新开一个终端,远程登陆服务器:

$ ssh [email protected]

在服务器端定义好部署结构:

ubuntu@VM $ mkdir web
ubuntu@VM $ mkdir web/flasky
ubuntu@VM $ mkdir web/log

即:

  • web/    Web App根目录
    • flasky/  存放python文件
    • log/    存放日志文件

我们使用Fabric将代码上传到服务器,首先,安装Fabric:

(venv) ~/web$ sudo apt-get install fabric

在web目录下创建fabfile.py(必须这个名字),写入:

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import os, re
from datetime import datetime

# 导入Fabric API:
from fabric.api import *

# 服务器登录用户名:
env.user = 'ubuntu'
# sudo用户为root:
env.sudo_user = 'root'
# 服务器地址,可以有多个,依次部署:
env.hosts = ['139.199.184.183']

_TAR_FILE = 'dist-flasky.tar.gz'

def build():
    includes = ['app', 'migrations', 'requirements', 'tests', 'venv', *.py', '*.sqlite']
    excludes = ['.*', '*.pyc', '*.pyo']
    local('rm -f dist/%s' % _TAR_FILE)
    with lcd(os.path.join(os.path.abspath('.'), 'flasky')):
        cmd = ['tar', '--dereference', '-czvf', '../dist/%s' % _TAR_FILE]
        cmd.extend(['--exclude='%s'' % ex for ex in excludes])
        cmd.extend(includes)
        local(' '.join(cmd))


_REMOTE_TMP_TAR = '/tmp/%s' % _TAR_FILE
_REMOTE_BASE_DIR = '/home/ubuntu/web/flasky'

def deploy():
    newdir = 'flask-%s' % datetime.now().strftime('%y-%m-%d_%H.%M.%S')
    # 删除已有的tar文件:
    run('rm -f %s' % _REMOTE_TMP_TAR)
    # 上传新的tar文件:
    put('dist/%s' % _TAR_FILE, _REMOTE_TMP_TAR)
    # 创建新目录:
    with cd(_REMOTE_BASE_DIR):
        sudo('mkdir %s' % newdir)
    # 解压到新目录:
    with cd('%s/%s' % (_REMOTE_BASE_DIR, newdir)):
        sudo('tar -xzvf %s' % _REMOTE_TMP_TAR)
    # 重置软链接:
    with cd(_REMOTE_BASE_DIR):
        sudo('rm -f flask')
        sudo('ln -s %s flask' % newdir)
        sudo('chown ubuntu:ubuntu flask')
        sudo('chown -R ubuntu:ubuntu %s' % newdir)
    # 重启Python服务和nginx服务器:
    #with settings(warn_only=True):
    #    sudo('supervisorctl stop flask')
    #    sudo('supervisorctl start flask')
    #    sudo('/etc/init.d/nginx reload')

使用fab命令将代码打包:

(venv) ~/web$ mkdir dist
(venv) ~/web$ fab build

将代码传上服务器:

(venv) ~/web$ fab deploy

Gunicorn部署

gunicorn入门看这里https://www.jianshu.com/p/260f18aa5462

代码上传给服务器后,可以直接运行manage.py文件,就可以访问网站了。可是实际情景中需要处理高并发访问的情况,我们使用Gunicorn来解决这个问题。

在服务器上进入flask所在目录,激活虚拟环境,并安装gunicorn:

ubuntu@VM ~/web/flasky/flask$ source venv/bin/activate
(venv) ubuntu@VM ~/web/flasky/flask$  sudo apt-get install gunicorn

使用gunicorn运行web应用(支持4个并发请求):

(venv) ubuntu@VM ~/web/flasky/flask$ gunicorn -w 4 -b 172.16.0.17:5000 manage:app

其中172.16.0.17是服务器内网ip,这样设置后就可以通过外网ip访问网站了。在浏览器地址栏中输入139.199.184.183:5000,就可以看到网站了。

Nginx

Nginx入门看这里

使用gunicorn的话,需要将端口暴露给外界,这不利于服务器的安全问题。Nginx是一个高性能的HTTP和反向代理服务器,通过配置一个代理服务器,可以实现反向代理的功能。所谓反向代理,是指一个请求,从互联网过来,先进入代理服务器,再由代理服务器转发给局域网的目标服务器。

先安装nginx:

(venv) ubuntu@VM ~$ sudo apt-get install nginx

设置反向代理服务器:在服务器,进入目录/etc/nginx/sites-available/,在目录下的default文件写入一个server。

首先,先备份default文件:

$ cd /etc/nginx/sites-available/
$ sudo cp default default-backup

在default文件中写入server:

server {
    listen 80;
    root /home/ubuntu/web/flasky/flask/;

    location / {
        proxy_pass http://127.0.0.1:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Forward-For $proxy_add_x_forwarded_for;
    }
}

配置完成后,重启nginx:

$ sudo nginx -s reload

此时,该反向代理服务器就开始监听80端口。80端口是为HTTP开放的端口,浏览网页服务默认的端口号都是80 (8080端口跟80端口一样)。只要访问服务器,代理服务器就会将请求转发到127.0.0.1:5000.

回到目录/home/ubuntu/web/flasky/flask/下,再次使用gunicorn运行web app:

(venv) ubuntu@VM ~/web/flasky/flask$ gunicorn -w 4 -b 127.0.0.1:5000 manage:app

用的ip地址是127.0.0.1

而外界要访问网站只需要在浏览器地址栏输入139.199.184.183,使用默认端口80。这样web app实际使用的5000就不用暴露了。

Supervisor

supervisor入门看这里https://www.jianshu.com/p/0226b7c59ae2

如果你需要进程一直执行,若该进程因各种原因中断,也会自动重启的话,supervisor是一个很好的选择。

supervisor管理进程,是通过fork/exec的方式将这些被管理的进程当作supervisor的子进程来启动,所以我们只需要将要管理进程的可执行文件的路径添加到supervisor的配置文件中就好了。此时被管理进程被视为supervisor的子进程,若该子进程异常终端,则父进程可以准确的获取子进程异常终端的信息,通过在配置文件中设置autostart=true,可以实现对异常中断的子进程的自动重启。

安装supervisor:

(venv) ubuntu@VM ~$ sudo apt-get install supervisor

在目录/etc/supervisor/conf.d/下创建flask.conf,并加入:

;/etc/supervisor/conf.d/flask.conf

[program:flask]

command     = /home/ubuntu/.local/bin/gunicorn -w 4 -b 127.0.0.1:5000 manage:app
;这里/home/ubuntu/.local/bin/是我服务器上gunicorn的安装目录
directory   = /home/ubuntu/web/flasky/flask
user        = ubuntu
startsecs   = 3
autostart   = true

redirect_stderr         = true
stdout_logfile_maxbytes = 50MB
stdout_logfile_backups  = 10
stdout_logfile          = /home/ubuntu/web/flasky/log/app.log

配置完后,进入目录/home/ubuntu/web/flasky/, 创建log目录:

(venv) ubuntu@VM ~/web/flasky$ mkdir log

启动supervisor:

(venv) ubuntu@VM /etc/supervisor$ sudo supervisord -c supervisor.conf                 

执行服务(运行app.py):

(venv) ubuntu@VM $ sudo supervisorctl start flask

此时,进程flask运行,执行command后边的语句,即/home/ubuntu/.local/bin/gunicorn -w 4 -b 127.0.0.1:5000 manage:app。

在浏览器地址栏输入139.199.184.183,使用默认端口80,即可访问网站。

如果supervisor遇到错误,可以在/var/log/supervisor/supervisord.log中查看日志;
如果app运行出现问题,可以在 /home/ubuntu/web/flasky/log/app.log中查看日志。

自动化部署

为了实现自动化部署,将上边fabfile.py文件的最后四个语句的注释取消,就能在将修改后的代码传上服务器后,用supervisor自动重载配置并重启flask进程。之后便可以直接访问网站。
因此,每次更改代码后,只需要执行以下两个语句,无需登陆服务器,便可以启动网站:

$ fab build
$ fab deploy

gunicorn配置文件

gunicorn的配置除了可以在命令行中设置,也可以使用配置文件实现更复杂的配置:

$ gunicorn -c gunicorn.py manage:app

gunicorn.py文件如下:

# gunicorn.py
import logging
import logging.handlers
from logging.handlers import WatchedFileHandler
import os
import multiprocessing
bind = '127.0.0.1:5000'       #绑定ip和端口号
backlog = 512                 #监听队列
chdir = '/home/test/server/bin'   #gunicorn要切换到的目的工作目录
timeout = 30      #超时
worker_class = 'gevent' #使用gevent模式,还可以使用sync 模式,默认的是sync模式
workers = multiprocessing.cpu_count() * 2 + 1    #进程数

threads = 2 #指定每个进程开启的线程数

loglevel = 'info' #日志级别,这个日志级别指的是错误日志的级别,而访问日志的级别无法设置
access_log_format = '%(t)s %(p)s %(h)s "%(r)s" %(s)s %(L)s %(b)s %(f)s" "%(a)s"'     #设置gunicorn访问日志格式,错误日志无法设置
"""
其每个选项的含义如下
        h           remote address
        l           '-'
        u           currently '-', may be user name in future releases
        t           date of the request
        r           status line (e.g. ``GET / HTTP/1.1``)
        s           status
        b           response length or '-'
        f           referer
        a           user agent
        T           request time in seconds
        D           request time in microseconds
        L           request time in decimal seconds
        p           process ID
        {Header}i   request header
        {Header}o   response header
"""
accesslog = "/home/ubutnu/web/flasky/log/gunicorn_access.log"      #访问日志文件
errorlog = "/home/ubutnu/web/flasky/log/gunicorn_error.log"        #错误日志文件

在本地将gunicorn.py放在/home/ubutnu/web/flasky/flask/目录下,在服务器端将/etc/supervisor/conf.d/flask.conf中的command改为:

command     = /home/ubuntu/.local/bin/gunicorn -c /home/ubutnu/web/flasky/flask/gunicorn.py manage:app

然后,在本地执行:

$ fab build
$ fab deploy

便可以访问网站了。

未分类

Django+Ngnix+Gunicorn+Mysql部署Centos的坑

环境配置

  • Centos 7
  • Python 3.6.5
  • Virtualenvwrapper 4.8.2
  • Django 2.0.5
  • Mysql 5.7.22
  • Ngnix 1.12.2
  • Gunicorn 19.8.1

注:这并不是什么教程

python虚拟环境配置

Virtualenvwrapper安装失败

试试这条命令 :-p

sudo pip install virtualenvwrapper --upgrade --ignore-installed six

简答解释就是包six版本有点低,详细解释点此

找不到virtualenvwrapper.sh文件

按照官方文档上说是安在 /usr/local/bin/virtualenvwrapper.sh,但是并没有,每个系统的情况不一样,使用如下命令

pip uninstall virtualenvwrapper

不用担心,这并不会立刻移除virtualenvwrapper,会输出以下内容,再输入n取消安装

Uninstalling virtualenvwrapper-4.8.2:
  /usr/bin/virtualenvwrapper.sh
  /usr/bin/virtualenvwrapper_lazy.sh
  /usr/lib/python2.7/site-packages/virtualenvwrapper-4.8.2-py2.7-nspkg.pth
  /usr/lib/python2.7/site-packages/virtualenvwrapper-4.8.2.dist-info/DESCRIPTION.rst
  /usr/lib/python2.7/site-packages/virtualenvwrapper-4.8.2.dist-info/INSTALLER
  /usr/lib/python2.7/site-packages/virtualenvwrapper-4.8.2.dist-info/METADATA
  ......
  Proceed (y/n)?

看第一行,这下知道在哪里的吧,对于我的centos7来说是在 /usr/bin/virtualenvwrapper.sh 下

具体见此https://stackoverflow.com/questions/12647266/where-is-virtualenvwrapper-sh-after-pip-install/41676706#41676706

Mysql配置

安装教程https://www.digitalocean.com/community/tutorials/how-to-install-mysql-on-centos-7 ,比较靠谱

中文乱码

问题可能出现在两个地方,一个是Django的配置文件中,还有一个就是Mysql的配置出问题

Django数据配置

找到project的settings.py,修改这两个地方,注意,对于较新版本的django,把zh-cn改成了zh-Hans

LANGUAGE_CODE = 'zh-Hans'

TIME_ZONE = 'Asia/Shanghai'

Mysql数据配置

先登录到你的mysql中,执行如下命令

SHOW VARIABLES LIKE 'character_set_%';

发现大多数行的值都不是utf-8,而是latin1

那么,找到mysql的配置文件my.cnf

对于 MySQL 5.7+,执行以下命令,别的情况见此

mysqladmin --help | grep 'Default options' -A 2

输出的第二行就是文件的所在

Default options are read from the following files in the given order:
/etc/my.cnf /etc/mysql/my.cnf /usr/etc/my.cnf ~/.my.cnf

打开此文件 /etc/my.cnf

添加如下内容如下,别的地方别修改

[mysqld]
collation-server = utf8_unicode_ci
init-connect='SET NAMES utf8'
character-set-server = utf8

...

[mysql]
default-character-set=utf8

改完之后记得重启mysql服务

sudo systemctl restart mysqld

gunicorn找不到 django.core.xxx

找到gunicorn的所在地

which gunicorn

应为是在python虚拟环境下安装的,所以一般在//.virtualenvs//bin/gunicorn,如果不是这样的话终极解决方案是把要输入 gunicorn 的地方全改成 //.virtualenvs//bin/gunicorn

Django 静态文件404

在production模式下Django并不支持静态文件的处理,这一切都要交给一个服务器处理,比如此处的Nginx,千万要记住!!!!!!

Nginx无法正常启动

(ps1:centos7安装Nginx的教程见此,比较靠谱)

(ps2:默认相关防火墙已开启)

在输入

sudo systemctl start nginx
sudo systemctl status nginx

发现其启动失败,则多半是你配置文件写错的结果,输入一下命令排错

sudo nginx -t

修改完之后记得刷新哦

sudo service nginx restart
#或者
sudo service nginx reload

python编程(webpy + gunicorn + nginx部署)

之前虽然也用nginx + uwsgi + webpy的方法部署过网站,但是用了gunicorn之后,发现用这种方法部署网站更为简单。下面我详细描述一下如何用这种方法进行网站部署。

1、准备server.py

和uwsgi部署的时候一样,这里仅仅需要设置一个application就可以了。

#!/usr/bin/python
import web

urls = ('/', 'Hello')

class Hello(object):
    def GET(self):
        return 'Hello world'

app = web.application(urls, globals())  
application = app.wsgifunc()

2、安装gunicorn

安装gunicorn的方法非常简单,在ubuntu下面一条命令就可以解决,

sudo apt-get install gunicorn

3、用gunicorn启动server.py文件

启动的时候注意,最后一个选项是由文件名+wsgifunc组成的。同时,我们在选项中添加了gevent的属性,gunicorn本身支持gevent机制,可以有效提高server的性能。

gnicorn -b 127.0.0.1:8080 --worker-class gevent server:application

4、用浏览器做测试

这个时候不出意外,你已经可以用127.0.0.1:8080访问我们的网站了。

5、准备nginx.conf文件

通常为了利用nginx做static文件加速,或者利用nginx做均衡负载,我们常常需要另外安装一下nginx软件。因此,此时nginx.conf必须准备好。当然,为了简单起见,我们这里只做一个代理就可以了,整个conf文件内容如下,

worker_processes 1;

events{
    worker_connections 1024;
}

http{

    sendfile on;
    keepalive_timeout 65;

    server {
        listen       80;
        server_name  localhost;

        location / {

            proxy_pass http://127.0.0.1:8080;
        } 
    }

}

6、重启启动nginx

nginx.conf准备好后,这个时候先将它copy到/etc/nginx目录下。接下来,我们需要重新启动nginx软件,一个命令就可以了,

service nginx restart

7、用浏览器测试80端口

有了nginx做代理,这个时候就可以用浏览器访问127.0.0.1了,因为一般网站默认用80做端口,所以没有意外的话,这个时候你就可以看到webpy给出的打印消息了。

supervisor 和gunicorn部署django项目

安装使用到的基本软件nginx、supervisor、gunicorn

vi /etc/supervisor/conf.d/django_project.conf
[program:django_project]
command=gunicorn xxx.wsgi:application -b 127.0.0.1:8080 -w 8
user=user #当前用户
directory=/home/user/django_project
stdout_logfile=/tmp/var/logs/supervisor/%(program_name)s-stdout.log
stderr_logfile=/tmp/var/logs/supervisor/%(program_name)s-stderr.log
killasgroup=true
stopasgroup=true
autorstart=true
autorestart=true

# rq队列的配置

[program:rqworker]
command=python manage.py rqworker default low
user=user
directory=/home/django_project/platform
stdout_logfile=/tmp/var/logs/supervisor/%(program_name)s-stdout.log
stderr_logfile=/tmp/var/logs/supervisor/%(program_name)s-stderr.log
killasgroup=true
stopasgroup=true
autorstart=true
autorestart=true```

再在nginx配置中的location,添加

proxy_pass http://127.0.0.1:8080;

另外静态文件的代理可以添加下面的配置

location /static/ {

alias /django_project/statics/;

}

使用 Nginx 和 Gunicorn 部署 Django 博客

我们博客的基础功能已经开发的基本差不多了,虽然还有很多地方可以完善,但我们还是希望早点把博客部署到服务器上,让他人可以通过外网访问。至于有待完善的地方,可以等部署完后一点点地迭代和改进。现在就让我们来把博客部署到服务器上吧!

注意:本文的每一个步骤都在真实环境下验证无误。除非你知道自己在做什么,否则我们建议每一步均严格按照教程的指导来,这样能保证你顺利完成部署。

部署前准备

我们将使用比较流行的 Nginx + Gunicorn 的方式将 Django 开发的博客部署到自己的服务器,让别人能够通过域名访问你的博客。至于 Nginx、Gunicorn 是什么暂时放到一边,读完本教程后你就会知道它们的作用和使用方法了。
为了部署我们的博客,需要满足以下两个条件:

  1. 有一台可以通过外网访问的服务器。
  2. 有一个域名。

如果你已经满足以上条件,可以直接跳到后面的搭建服务器部分。这里简单介绍一下我目前所知的以最低成本满足以上两个条件的方式。

购买服务器

如果你是学生,推荐购买阿里云服务器,学生优惠价是 9.9 元/月,而且服务器性能比较高。购买地址:阿里云服务器学生专区。具体的购买步骤这里就不赘述了,根据网站的指引相信你肯定能够购买成功。只是注意一点的是在选服务器类型的时候选择公共镜像,这样系统比较纯净。操作系统建议选 ubuntu 14.04 64位,这是本教程使用的服务器环境。

如果你不是学生,推荐购买搬瓦工 vps。目前最便宜的是 19.9美元/年,缺点是服务器性能没有阿里云高,但优点是顺带可以用它来搭梯子,从此访问 google、youtube 不是梦(基于 shadowsocks 只需简单几步就可以搭建起自己的梯子服务器)。同样购买的过程就不赘述了,搬瓦工 vps 中文网 有超级详细的指引。只是注意安装操作系统时建议选 ubuntu 14.04 64位,这是本教程使用的服务器环境。

如果你不差那点钱,随意选择一个云服务器提供商购买一个云服务器即可。

购买域名

域名服务商很多,我这里使用的是 阿里云域名注册系统。域名是网站的门牌,如果打算长期运营这个网站建议多考虑考虑,选一个适当的域名。如果只是为了测试,随便注册一个域名即可,一些非常见后缀的域名非常便宜,一般 10元/年就能搞定。但注意一点根据工信部规定,以下后缀的域名需要实名认证后才能使用:

.cn/.com/.net/.top/.xyz/.vip/.club/.ren/.wang/.shop/.xin/.中国/.信息/.公司/.网络/.广东/.佛山

如果你购买的是上述后缀的域名,意味着需要提交个人的身份资料实名认证后才能正常使用,这通常需要花费几天的时间。所以如果只为了测试和学习部署的话,最好避开上述后缀的域名。

搭建服务器

本教程使用的本地环境为 Windows 10,服务器环境为 ubuntu 14.04(64 位)。如果你的环境和我的有所差异导致一些命令无法执行,将这些命令转换为你所在环境的命令执行即可。

远程登录到服务器

服务器通常位于云端,需要使用远程登录工具登录后才能对服务器进行操作。我使用的是 Xshell,Windows 下百度 Xshell 下载安装即可,软件对学校和个人用户是免费的。
如何远程登录到服务器这里就不赘述了,相信你参考网上的一些教程肯定能够顺利登录。假如你和我一样使用 Xshell 的话,这里有一篇很详细的教程可以参考:教你怎么使用xshell远程连接linux服务器。

安装软件

顺利连接到远程服务器了。如果是一台全新服务器的话,通常我们是以 root 用户登录的。在 root 下部署代码不安全,最好是建一个新用户(如果你已经以非 root 用户登录的话可以跳过这一步)。下面的一些列命令将创建一个拥有超级权限的新用户:

# 在 root 用户下运行这条命令创建一个新用户,yangxg 是用户名
# 因为我叫杨学光,所以我取的用户名是 yangxg
# 选择一个你喜欢的用户名,不一定非得和我的相同
root@localhost:~# useradd -m -s /bin/bash yangxg

# 把新创建的用户加入超级权限组
root@localhost:~# usermod -a -G sudo yangxg

# 为新用户设置密码
# 注意在输密码的时候不会有字符显示,不要以为键盘坏了,正常输入即可
root@localhost:~# passwd yangxg

# 切换到创建的新用户
root@localhost:~# su - yangxg

# 切换成功,@符号前面已经是新用户名而不是 root 了
yangxg@localhost:~$

新用户创建并切换成功了。如果是新服务器的话,最好先更新一下系统,避免因为版本太旧而给后面安装软件带来麻烦。运行下面的两条命令:

yangxg@localhost:~$ sudo apt-get update
yangxg@localhost:~$ sudo apt-get upgrade

接下来就可以安装必要的软件了,这里我们需要用到的软件有 Nginx、Pytohn3、Git、pip 和 virtualenv。

yangxg@localhost:~$ sudo apt-get install nginx
yangxg@localhost:~$ sudo apt-get install git python3 python3-pip
yangxg@localhost:~$ sudo pip3 install virtualenv

解析域名到服务器的 IP 地址

将域名和服务器的 IP 地址绑定后,用户就可以通过在浏览器输入域名来访问服务器了。

各大域名服务商都提供了域名解析服务,但其配置界面各有差异,请依据其指引完成域名解析。下面是我使用的阿里云域名解析页面。

未分类

启动 Nginx 服务

Nginx 是用来处理静态文件请求的。比如当我们访问一个博客文章详情页面时,服务器会接收到下面两种请求:

  • 显示文章的详情信息,这些信息通常保存在数据库里,因此需要调用数据库获取数据。
  • 图片、css、js 等存在服务器某个文件夹下的静态文件。

对于前一种请求,博客文章的数据需要借助 Django 从数据库中获取,Nginx 处理不了,它就会把这个请求转发给 Django,让 Django 去处理。而对于后一种静态文件的请求,只需要去这些静态文件所在的文件夹获取,Nginx 就会代为处理,不再麻烦 Django。

用 Django 去获取静态文件是很耗时的,但 Nginx 可以很高效地处理,这就是我们要使用 Nginx 的原因(当然其功能远不止这些)。

通过前面的步骤我们已经安装了 Nginx,并且已经把域名和服务器 IP 绑定了。运行下面的命令启动 Nginx 服务:

yangxg@localhost:~$ sudo service nginx start

在浏览器输入域名,看到如下页面说明 Nginx 启动成功了。

未分类

部署代码

部署前的项目配置

Django 项目中会有一些 CSS、JavaScript 等静态文件,为了能够方便地让 Nginx 处理这些静态文件的请求,我们把项目中的全部静态文件收集到一个统一的目录下,这个目录通常位于 Django 项目的根目录,并且命名为 static。为了完成这些任务,需要在项目的配置文件里做一些必要的配置:

blogproject/settings.py

# 其他配置...

STATIC_URL = '/static/'
# 加入下面的配置

STATIC_ROOT = os.path.join(BASE_DIR, ‘static’)STATIC_ROOT 指明了静态文件的收集目录,即项目根目录(BASE_DIR)下的 static 文件夹。

为了安全起见,在生产环境下需要关闭 DEBUG 选项以及设置允许访问的域名。打开 settings.py 文件,找到 DEBUG 和 ALLOWED_HOSTS 这两个选项,将它们设置成如下的值:

blogproject/settings.py

DEBUG = False

ALLOWED_HOSTS = [‘127.0.0.1’, ‘localhost ‘, ‘.zmrenwu.com’]ALLOWED_HOSTS 是允许访问的域名列表,127.0.0.1 和 localhost 是本地访问的域名,.zmrenwu.com 是访问服务器的域名(换成你自己的域名)。域名前加一个点表示允许访问该域名下的子域名,比如 www.zmrenwu.com、test.zmrenwu.com 等二级域名同样允许访问。如果不加前面的点则只允许访问 zmrenwu.com。

项目还会依赖一些第三方 Python 库,为了方便在服务器上一次性安装,我们将全部依赖写入一个叫 requirements.txt 的文本文件中。激活本地的虚拟环境(如果你使用了虚拟环境的话),并进入项目的根目录,运行 pip freeze > requirements.txt 命令:

(blogproject_env) C:UsersyangxgWorkspaceblogproject>
pip freeze > requirements.txt

这时项目根目录下会生成了一个 requirements.txt 的文本文件,其内容记录了项目的全部依赖。

将代码上传到 GitHub

将代码上传到 GitHub 等代码托管平台,这样我们就可以方便地把代码拉取到服务器了。Git 和 GitHub 的使用相信你已经很熟悉了,这里就不赘述过程。如果不知道如何使用地话可以自行百度相关教程。
注意数据库文件不要上传!

设置服务器目录结构

接下来需要把代码上传到服务器了。我服务器上存放代码的目录结构一般是这样的:

/home/yangxg/
    sites/
        demo.zmrenwu.com/
            env/
            django-blog-tutorial/

一台服务器可能部署多个网站,所有网站代码都放在 sites/ 目录下。demo.zmrenwu.com/ 这个文件夹以网站的域名命名,便于区分。env/ 是 python 虚拟环境目录。django-blog-tutorial/ 是 Django 博客项目目录。

因此先来创建这个目录结构,注意目录名替换为你自己的域名,以后涉及到 demo.zmrenwu.com 的地方通常都要替换你自己的域名,后面就不再一一指出了,运行下面的命令,

yangxg@localhost:~$ mkdir -p ~/sites/demo.zmrenwu.com

这里 ~ 代表当前用户的 home 目录,即 /home/yangxg/。

接下来创建虚拟环境,先进入到 demo.zmrenwu.com 目录下,然后运行 virtualenv 命令创建虚拟环境:

yangxg@localhost:~$ cd ~/sites/demo.zmrenwu.com
yangxg@localhost:~/sites/demo.zmrenwu.com$ virtualenv --python=python3 env

注意这里使用 –python=python3 来指定克隆 Python3 的环境。因为 ubuntu 系统默认安装了 Python2,如果不特别指定的话 Virtualenv 默认克隆的是 Python2 的环境。

检查一下虚拟环境是否创建成功,运行 ls 命令列出当前目录下的文件和文件夹,看到 env 这个文件夹说明虚拟环境创建成功。

yangxg@localhost:~/sites/demo.zmrenwu.com$ ls
env

接着再从代码仓库把项目代码拉取过来,把 git clone 后的地址换成你自己的 GitHub 仓库地址!

yangxg@localhost:~/sites/demo.zmrenwu.com$ git clone https://github.com/zmrenwu/django-blog-tutorial.git

运行 ls 命令检查一下是否拉取成功:

yangxg@localhost:~/sites/demo.zmrenwu.com$ ls
django-blog-tutorial  env

多了 django-blog-tutorial 文件夹(文件夹名称由你的 GitHub 仓库名决定),说明拉取成功了。

安装项目依赖

激活虚拟环境,再进入到项目根目录,即 requirements.txt 所在的目录,安装项目的全部依赖:

yangxg@localhost:~/sites/demo.zmrenwu.com$ source env/bin/activate
(env) yangxg@localhost:~/sites/demo.zmrenwu.com$ cd django-blog-tutorial/
(env) yangxg@localhost:~/sites/demo.zmrenwu.com/django-blog-tutorial$ pip install -r requirements.txt

收集静态文件

虚拟环境下继续运行 python manage.py collectstatic 命令收集静态文件到 static 目录下:

(env) yangxg@localhost:~/sites/demo.zmrenwu.com/django-blog-tutorial$ python manage.py collectstatic

生成数据库

虚拟环境下继续运行 python manage.py migrate 命令创建数据库文件:

(env) yangxg@localhost:~/sites/demo.zmrenwu.com/django-blog-tutorial$ python manage.py migrate

创建超级用户

虚拟环境下继续运行 python manage.py createsuperuser 命令创建一个超级用户,方便我们进入 Django 管理后台。这和本地开发时是一样的,具体请参照:在 Django Admin 后台文章。

(env) yangxg@localhost:~/sites/demo.zmrenwu.com/django-blog-tutorial$ python manage.py createsuperuser

配置 Nginx

接下是配置 Nginx 来处理用户请求。

先在服务器的 /etc/nginx/sites-available/ 目录下新建一个配置文件,文件名我一般就设置为域名。写上下面的配置内容:
/etc/nginx/sites-available/demo.zmrenwu.com

server {
    charset utf-8;
    listen 80;
    server_name demo.zmrenwu.com; ①

    location /static { ②
        alias /home/yangxg/sites/demo.zmrenwu.com/django-blog-tutorial/static; 
    }

    location / { ③
        proxy_set_header Host $host;
        proxy_pass http://unix:/tmp/demo.zmrenwu.com.socket;
    }
}

① 服务的域名为 demo.zmrenwu.com。

② 所有URL 带有 /static 的请求均由 Nginx 处理,alias 指明了静态文件的存放目录。

③ 其它请求转发给 Django 处理。proxy_pass 后面使用了 unix 套接字,其作用是防止端口冲突,这里就不再详述。

至于怎么在服务器新建文件和写文件,请自行学习一点点 vi 编辑器的用法,这里也不一一讲解了。

我们在 /etc/nginx/sites-available/ 放置了配置文件,接下来需要创建一个符号链接,把这个配置文件加入到启用的网站列表中去,被启用网站的目录在 /etc/nginx/sites-enabled/,你可以理解为从 sites-available/ 目录下发送了一个配置文件的快捷方式到 sites-enabled/ 目录。具体命令如下:

(env) yangxg@localhost:~/sites/demo.zmrenwu.com/django-blog-tutorial$ sudo ln -s /etc/nginx/sites-available/demo.zmrenwu.com /etc/nginx/sites-enabled/demo.zmrenwu.com

使用 Gunicorn

Gunicorn 一般用来管理多个进程,有进程挂了Gunicorn 可以把它拉起来,防止服务器长时间停止服务,还可以动态调整 worker 的数量,请求多的时候增加 worker 的数量,请求少的时候减少。
在虚拟环境下,安装 Gunicorn:

(env) yangxg@localhost:~/sites/demo.zmrenwu.com/django-blog-tutorial$ pip install gunicorn

用 Gunicorn 启动服务器进程:

(env) yangxg@localhost:~/sites/demo.zmrenwu.com/django-blog-tutorial$ gunicorn --bind unix:/tmp/demo.zmrenwu.com.socket blogproject.wsgi:application

浏览器输入域名,可以看到访问成功了!

自动启动 Gunicorn

现在 Gunicorn 是我们手工启动的,万一哪天服务器崩溃重启了又得重新手工启动。为此我们写一个自动启动脚本,这样当服务器重新启动后,脚本会帮我们重启 Gunicorn。先按 Ctrl + c 停止刚才启动的服务器进程。

写一个启动脚本,这样当服务器重启后能自动引导 Gunicorn 的启动。脚本位于 /etc/init/ 目录下,且脚本文件名必须以 .conf 结尾:

/etc/init/gunicorn-demo.zmrenwu.com.conf

start on net-device-up ①
stop on shutdown

respawn ②

setuid yangxg ③
chdir /home/yangxg/sites/demo.zmrenwu.com/django-blog-tutorial ④

exec ../env/bin/gunicorn --bind unix:/tmp/demo.zmrenwu.com.socket blogproject.wsgi:application ⑤

① start on net-device-up 确保只在服务器联网时才启动 Gunicorn。

② 如果进程崩溃了(比如服务器重启或者进程因为某些以外情况被 kill),respawn 将自动重启 Gunicorn。

③ setuid 确保以 yangxg 用户的身份(换成你自己的用户名)运行 Gunicorn 进程。

④ chdir 进入到指定目录,这里进入项目的根目录。

⑤ exec 执行进程,即开启服务器进程。

现在可以用 start 命令启动 Gunicorn 了:

sudo start gunicorn-demo.zmrenwu.com

以后如果更新了代码,只要运行下面的命令重启一下 Nginx 和 Gunicorn 就可以使新的代码生效了:

sudo service nginx reload
sudo restart gunicorn-demo.zmrenwu.com

使用 CDN 加快 Bootstrap 和 jQuery 的加载速度

我们的项目使用了 Bootstrap 和 jQuery,这两个文件我们是从本地加载的。如果服务器性能比较差的话,加载需要耗费很长的时间,网站打开的速度就变得无法忍受。我们使用 CDN 来加快加载速度。具体来说,替换 base.html 的几个静态文件的加载标签:

base.html

- <link rel="stylesheet" href="{% static 'blog/css/bootstrap.min.css' %}">
- <script src="{% static 'blog/js/jquery-2.1.3.min.js' %}"></script>
- <script src="{% static 'blog/js/bootstrap.min.js' %}"></script>
+ <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
+ <script src="https://cdn.bootcss.com/jquery/2.1.3/jquery.min.js"></script>
+ <script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>

这样网站访问的速度将大大提升!

部署过程自动化

在整个部署过程中我们运行了十几条命令,手动输入了 N 个字符。如果每次更新代码都要远程连接到服务器执行这些命令的话将变得非常麻烦。接下来的教程我们将介绍使用 Fabric 自动化整个部署过程。写好部署脚本后,只需要执行一条命令,就可以非常方便地自动完成整个部署。

python利用flask,gunicorn部署接口全过程

背景

无论开发 Android 还是 Web 端程序,有时候不免需要一些接口供自己调用进行测试,这里记录一下详细的过程。

环境配置

1、阿里云的 9.9 的学生特惠机, Ubuntu 14.04 64位

未分类

2、利用 putty 输入公网 ip 登录到服务器

先配置编码为 utf-8

未分类

未分类

输入账号密码

未分类

3、要利用 apt-get 包管理工具下载各种包,所以先更新下源,随手把 git 也安一下,安装中途输入 Y 即可

apt-get update
apt-get install git

未分类

Flask [flɑ:sk]

Flask是一个使用Python编写的轻量级Web应用框架。基于Werkzeug WSGI工具箱和Jinja2 模板引擎。 Flask 官方教程: http://docs.jinkan.org/docs/flask/index.html

我已经在本地写了一个简单的 Flask ,并且传到了 Coding

#coding=utf-8
from flask import Flask,jsonify,request
app = Flask(__name__) #获得 Flask 实例
 #写一个 POST 的方法,传一个 name 的参数,返回一个  json 数据
@app.route('/getJson', methods=['POST'])
def getJson():
    #bala bala,下边随便返回点东西
    name=request.form.get('name', default='windliang')
    data={
    'name':name,
    'place':'wuhan'
    }
    msg='get success'
    code=True
    return getBaseReturnValue(data,msg,code)
#返回 json 数据    
def getBaseReturnValue(data,msg,code):
  json_data = jsonify({'data':data,'msg':msg,'success':code})
  return json_data

if __name__ == '__main__':
    app.run(host='0.0.0.0') #在服务器上运行

依次执行下边的指令,‘//’后边的仅做注释不用复制

git clone https://git.coding.net/wind_liang/flasktest.git  //将 coding 上的代码克隆到本地
pip install virtualenv  //python 的一个创建隔离环境的工具
mkdir api  //创建一个新目录 api,virtualenv 直接用 clone 下的目录会出问题,原因不清楚
cp -i flasktest/api.py api  //将 coding 下载下来的 api.py 复制到新目录 api 中
cd api   // 进入 api 目录
virtualenv venv // 创建虚拟环境安包的文件夹
source venv/bin/activate //激活虚拟环境 ,这时会看到在最前边有 (venv) 标识 ,以后进入前都得先激活环境
pip install flask // 安装 flask 包
pip freeze > requirements.txt  // 将安装的包列表写到 reqirements.txt 中,
以后每次 pip 安装了新的库的时候,都需freeze 一次,
既能知道自己安装了什么库,也方便别人部署时,安装相应的库。
python api.py  // 运行程序 
ctrl+C 用于终止当前 python 程序
deactivate 用于关闭当前虚拟环境 ,先不用执行此句

virtualenv 是一个将不同项目所需求的依赖分别放在独立的地方的一个工具,它给这些工程创建虚拟的Python环境。它解决了“项目X依赖于版本1.x,而项目Y需要项目4.x”的两难问题,而且使你的全局site-packages目录保持干净和可管理。官方教程

阿里云还得设定开放 5000端口

未分类

未分类

此时利用 postman (谷歌浏览器的一个插件),或者 curl 等其他能发 post 请求的工具进行测试

未分类

未分类

ctrl+C 终止程序,进入下一步

gunicorn

Gunicorn是一个Python WSGI UNIX的HTTP服务器。这是一个预先叉工人模式,从Ruby的独角兽(Unicorn)项目移植。该Gunicorn服务器与各种Web框架兼容,我们只要简单配置执行,轻量级的资源消耗,以及相当迅速。现在我们使用 flask 自带的服务器,完成了 web 服务的启动。生产环境下,flask 自带的服务器,无法满足性能要求。我们这里采用 gunicorn 做 wsgi容器,用来部署 python

pip install gunicorn  //安装 gunicorn
pip freeze > requirements.txt //保存到当前安装的包的列表中
gunicorn -w4 -b0.0.0.0:8000 api:app
此时,我们需要用 8000 的端口进行访问,
原先的5000并没有启用。
其中 gunicorn 的部署中,
-w 表示开启多少个 worker,-b
表示 gunicorn  的访问地址 ,
api 是程序进入的文件名, 
app 是代码中获得的 flask 实例
进入阿里云记得开放8000端口

未分类

未分类

ctrl + c 终止当前程序

微信公众号服务器端 Flask 源码

python 2.7

# -*- coding: utf-8 -*-
# filename: main.py
from flask import Flask
import hashlib
import time
from flask import Flask,g,request,make_response
import xml.etree.ElementTree as ET
import requests 
import re
import os
from bs4 import BeautifulSoup
import warnings
app = Flask(__name__)
BASE_DIR = os.path.dirname(__file__) #获取当前文件夹的绝对路径
warnings.filterwarnings("ignore") #忽略警告
@app.route("/wx",methods=["GET","POST"])
def wx():
    if request.method == "GET":       # 判断请求方式是GET请求
        my_signature = request.args.get('signature')     # 获取携带的signature参数
        my_timestamp = request.args.get('timestamp')     # 获取携带的timestamp参数
        my_nonce = request.args.get('nonce')        # 获取携带的nonce参数
        my_echostr = request.args.get('echostr')         # 获取携带的echostr参数
        token = 'helloworld'     # 一定要跟微信端填写的token一致
        # 进行字典排序
        data = [token,my_timestamp ,my_nonce ]
        data.sort()
        # 拼接成字符串
        try:
            temp = ''.join(data)
        except:
            return "success"
        # 进行sha1加密
        mysignature = hashlib.sha1(temp).hexdigest()
        # 加密后的字符串可与signature对比,标识该请求来源于微信
        if my_signature == mysignature:
            return my_echostr
    else:
        rec = request.stream.read()
        xml_rec = ET.fromstring(rec)
        msgType=xml_rec.find("MsgType").text 
        if msgType != 'text': #只对文字进行回复
            return "success"
        tou = xml_rec.find('ToUserName').text
        fromu = xml_rec.find('FromUserName').text
        content = xml_rec.find('Content').text
        cc=content.encode('UTF-8') # 用户发送的文字
        t="狼吃羊"
        if(cc==t):
            content="http://windliang.oschina.io/worfeatsheep/"
        else:
            return "success"
        xml_rep = "<xml><ToUserName><![CDATA[%s]]></ToUserName><FromUserName><![CDATA[%s]]></FromUserName><CreateTime>%s</CreateTime><MsgType><![CDATA[text]]></MsgType><Content><![CDATA[%s]]></Content><FuncFlag>0</FuncFlag></xml>"
        response = make_response(xml_rep % (fromu,tou,str(int(time.time())), content))
        response.content_type='application/xml'
        return response

@app.route("/",methods=["GET"])
def index():
    return "hello,world"

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

搭建nginx gunicorn mysql环境部署django应用

说实在的第一次用服务器来部署django确实有点不知所措,上网查了一些资料,准备部署一个nginx+gunicorn+django+mysql的一个博客系统。

用户环境

  • 服务器:阿里云服务器ECS
  • 镜像系统:ubuntu16.04 64位
  • 准备建立:nginx+gunicorn+django+mysql的博客系统

首先登陆到云服务器,也不知道先干什么,那么先更新一下吧

sudo apt-get update
sudo apt-get upgrade

中间可能会询问一些问题,输入y即可。

nginx

简单介绍一下,nginx是一个轻量级的高性能的web服务器,反向代理服务器以及邮件服务器。首先来配置一下nginx

sudo apt-get install nginx

一阵等待之后nginx就安装好了,首先来看一下nginx.conf配置

# /etc/nginx/nginx.conf
user www-data;
worker_processes auto;
pid /run/nginx.pid;

events {
        worker_connections 768;
        # multi_accept on;
}

http {

        ##
        # Basic Settings
        ##

        sendfile on;
        tcp_nopush on;
        tcp_nodelay on;
        keepalive_timeout 65;
        types_hash_max_size 2048;

        include /etc/nginx/mime.types;
        default_type application/octet-stream;

        ##
        # SSL Settings
        ##

        ssl_protocols TLSv1 TLSv1.1 TLSv1.2; # Dropping SSLv3, ref: POODLE
        ssl_prefer_server_ciphers on;

        ##
        # Logging Settings
        ##

        access_log /var/log/nginx/access.log;
        error_log /var/log/nginx/error.log;

        ##
        # Gzip Settings
        ##

        gzip on;
        gzip_disable "msie6";

        ##
        # Virtual Host Configs
        ##

        include /etc/nginx/conf.d/*.conf;
        include /etc/nginx/sites-enabled/*;
}

这一段代码是安装nginx后的nginx的默认配置,关于nginx的配置优化后续再讲,现在重要的是将服务器给搭建起来,首先简单的讲解一下

在默认配置中,nginx总共分为四个部分:

1、全局设置,主要用来设置nginx的相关配置,比如设定nginx运行的用户和用户组、运行的进程数、运行的文件等。该部分设置在{}之外。

2、events设置,从字面理解,events就是事件的意思,这里是设置事件的相关配置,如事件处理方式是epoll还是select、单个进程的最大连接数,网络IO模型等。

3、http设置,这里是http服务器的相关配置,从默认配置看,大致有五种,基本配置、SSL配置、Log配置、Gzip配置以及虚拟端口设置。这里我们先看虚拟端口这只,这里用include引入了两个文件,/etc/nginx/conf.d/.conf 和/etc/nginx/site-enabled/。我这里就直接将我自己的服务器配置放在conf.d/blog.conf文件中。

server {
    listen 80;
    server_name final-skynet.xin;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real_IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

这段代码的意思是nginx监听80端口,服务器的地址是final-skynet.xin,location是一个匹配规则,匹配到监听的url,具体的匹配规则这里就不详细赘述了。匹配成功后,转发到本地的http://127.0.0.1:8080地址,这是gunicorn监听的地址,然后设置其他需要转发的内容。

4、最后一个是mail设置,由于本项目现在还用不着,所以就将默认的代码注释删除了。nginx的基本配置就到这里了。

安装gunicorn和django

sudo pip install gunicorn
sudo apt-get install django

输入上述命令就可以安装好django和gunicorn了,这里先简单的配置一下django,创建一个简单的blog应用。

1、创建新项目

django-admin startproject SkyNet

在根目录输入该命令就可以创建一个新的django项目SkyNet,然后创建一个新的blog应用

进入SkyNet文件夹可以看到该文件夹的目录结构如下

/SkyNet
    manage.py
    /SkyNet
        __init__.py
        settings.py
        urls.py
        wsgi.py

然后在SkyNet目录下运行以下命令

python manage.py startapp blog

然后可以看见SkyNet目录下多了一个blog的文件夹,这个就是新创建的blog app

2、创建index页面

那先创建一个index页面来验证一下我们的配置。

  • 在urls.py中进行配置
from django.conf.urls import url
from django.contrib import admin
from blog.views import *

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^$',index,name='index')
]
  • 创建index视图
from __future__ import unicode_literals

from django.shortcuts import render
from django.http import HttpResponse

def index(request):
    return HttpResponse('Hello , this is my first index')

现在需要在INSTALL_APPS配置创建的app和gunicorn

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'gunicorn',
    'blog',
]

下面需要通过gunicorn来启动django

gunicorn Skynet.wsgi:application -b 127.0.0.1:8080

最后在浏览器中输入网址进行验证

未分类

可能你需要重启一下你的nginx
讲到这个地方,云服务的环境部署应该是告一段落了

但是呢,在文章的开头,需要建立的是nginx+gunicorn+django+mysql的一个服务器,剩下的就是mysql的安装了

sudo apt-get install mysql-server

然后在安装的过程中提示需要设置密码,这个时候你可以选择设置密码,或者直接选择OK跳过。

我在这里是选择的跳过,安装完毕验证一下数据是否安装成功。由于我这里没有设置密码,故直接输入mysql就进入了mysql的命令行,设置密码的可以输入

mysql -u root -p

然后输入密码进入命令行。

在mysql创建数据库的时候经常出现编码问题,这里我先解决一下mysql的编码问题,在/etc/mysql/my.cnf中引用了conf.d中的文件,所以直接在/etc/mysql/conf.d/mysql.cnf进行修改。
首先查看一下mysql的编码,进入mysql命令行

mysql> show variables like 'char%';
+--------------------------+----------------------------+
| Variable_name            | Value                      |
+--------------------------+----------------------------+
| character_set_client     | utf8                       |
| character_set_connection | utf8                       |
| character_set_database   | latin1                     |
| character_set_filesystem | binary                     |
| character_set_results    | utf8                       |
| character_set_server     | latin1                     |
| character_set_system     | utf8                       |
| character_sets_dir       | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.00 sec)
//或者
mysql> status
--------------
mysql  Ver 14.14 Distrib 5.7.19, for Linux (x86_64) using  EditLine wrapper

Connection id:      4
Current database:
Current user:       root@localhost
SSL:            Not in use
Current pager:      stdout
Using outfile:      ''
Using delimiter:    ;
Server version:     5.7.19-0ubuntu0.16.04.1 (Ubuntu)
Protocol version:   10
Connection:     Localhost via UNIX socket
Server characterset:    latin1
Db     characterset:    latin1
Client characterset:    utf8
Conn.  characterset:    utf8
UNIX socket:        /var/run/mysqld/mysqld.sock
Uptime:         1 min 16 sec

可以看到db和server的characterset都默认为latin1,这里需要设置[mysqld]的character-set-server = utf8即可

//mysql.cnf
[mysqld]
character-set-server = utf8

然后重启mysql服务,在命令行输入

service mysql restart

然后重新查看,可以看到mysql的默认编码已经改过来了。

如果你不想这么麻烦,可以在创建数据库的时候设置编码为utf8即可
如下命令

CREATE DATABSE db_name DEFUALT CHARACTER SET utf8;

下面在django中配置mysql

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'blog',
        'USER': 'root',
        'PASSWORD': '',
        'HOST':'',
        'PORT':'',
    }
}

这里由于我的mysql用户没有设置密码所以,password为空,后续再进行设置
先需要在mysql中创建数据库。

CREATE DATABASE blog;

这个时候django还没有和mysql连接起来,需要安装mysqlclient或者MySQL-python,我在这里安装的是mysqlclient,在安装mysqlclient之前还需要安装libmysqlclient-dev

sudo apt-get install libmysqlclient-dev
pip install mysqlclient

这个时候就可以用django的数据迁移

python manage.py makemigrations
python manage.py migrate

这个时候进入mysql命令行,查看blog数据库中是否插入了django数据迁移来的数据库表

mysql> use blog
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> show tables;
+----------------------------+
| Tables_in_blog             |
+----------------------------+
| auth_group                 |
| auth_group_permissions     |
| auth_permission            |
| auth_user                  |
| auth_user_groups           |
| auth_user_user_permissions |
| django_admin_log           |
| django_content_type        |
| django_migrations          |
| django_session             |
+----------------------------+
10 rows in set (0.00 sec)

看到数据库中的表就可以指导mysql已经配置完成了。
这样SkyNet的服务器配置基本上就完成了。后面需要解决一下代码上传和nginx等优化的问题。

Flask服务部署(Nginx Gunicorn Gevent)

Flask 项目部署

我们开发好了一个flask项目, 需要部署到线上服务器, 那我们的线上服务应该如何部署呢

基本的架构如下

未分类

Nginx

在开发环境, 我们一般直接运行Python服务, 启动了某个端口(一般是5000端口), 然后通过该端口进行开发调试

但线上环境一般不会直接这样提供服务, 一般的线上服务需要通过 Nginx 将外部请求转发到Python服务

这样有什么好处

  • 隐藏python服务, 避免直接将python服务暴露出去
  • 提高web服务的连接处理能力(Nginx)
  • 作为反向代理, 提升python整体服务处理能力

我们可以配置的Nginx配置如下

upstream flask_servers {
    server 127.0.0.1:9889;
}

server {
    listen 80;
    server_name dev.simple-cms.com;

    access_log  /data/logs/nginx/simple_cms_access.log main;
    error_log /data/logs/nginx/simple_cms_error.log debug;

    location / {
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_redirect off;
        proxy_pass  http://flask_servers;
    }

    location ^~ /static {
        root /data/www;
    }
}

如果有多个python服务器, 可在upstream下继续添加其他的python服务列表

Gunicorn + Gevent

Gunicorn

Guicorn 是一个python的一个 WSGI 的web sever, 什么是WSGI

Web Server <=====WSGI=====> Python APP

WSGI 其实是一种网关协议, 用以把http请求参数转换为python服务可以读取的内容, 这样在python的框架里能根据请求参数进行不同的业务处理了

Gunicorn 就是这么一种WSGI的实现, 他也是个web server, 可以直接提供对外的web服务, 但在一般的部署中, 他只是作为python服务的运行的容器, 运行和管理python应用程序

通过这个容器, 从Nginx转发的请求就能转发到某个python app了

除此之外, Gunicorn 还提供了多个运行参数, 常用的如下

-w 设置启动`python app` worker进程的数量
-k 运行模式(sync, gevent等等)
-b gunicorn 启动绑定的host和port
--max-requests 最大处理量, 单woker进程如果处理了超过该数量的请求, 该woker会平滑重启

Gevent

单进程直接运行Python app服务时, 当有两个并发请求过来时, 进程只能先处理一个请求, 等第一个请求处理完成后, 才能处理第二个, 势必影响用户的体验

那么单进程的时候, 如何能提高并发处理能力,

大多数情况下, 我们的服务中, 导致性能低下的原因是I/O, 比如对数据库的读写, 发送Http请求等等, 当进程进行I/O的时候, 是不占用CPU时间的, 这个时候, CPU可以被腾出来处理其他请求

Gevent就是完成这个工作的

幸运的是, 我们不需要再代码中自己实现这部分功能, Gunicorn 实现了Gevent模式的运行方式(-k 参数指定), 允许你的Python APP 更高性能的处理业务

通过 Gunicorn + Gevent, 我们可以如下启动

gunicorn --max-requests 300 --pid /tmp/flask.pid --timeout 3 -k gevent -w 2 -b 127.0.0.1:9889 run:app

从Nginx代理的请求, 就可以转发到Gunicorn启动的9889端口上了

supervisor

上面我们通过Gunicorn+Gevent 启动了Python服务, 在某些情况下, 我们的服务会停掉(系统掉电重启, 误杀, 不知道停了 🙁 ),

我们不可能时刻都看着线上服务, 在这种情况下, 我们希望系统能自动拉起停掉的服务, 保证线上服务的稳定

supervisor 就是干这个的, supervisor会守护配置好的进程, 在进程停止后重新启动服务进程, 并保留日志

比如Nginx服务的配置可以如下

[program:nginx]
command = /usr/local/bin/nginx -g 'daemon off;' -c /usr/local/etc/nginx/nginx.conf
autostart = true
startsecs = 5
autorestart = true
startretries = 3
user = root

其中command 就是我们nginx服务的启动命令,

同理, gunicorn启动的supervisor 配置如下

[program:gunicorn]
directory=/path/to/flask_app
command = /path/to/gunicorn --max-requests 3000 --pid /tmp/flask.pid --timeout 3 -k gevent -w 2 -b 127.0.0.1:9889 run:app autostart = true
startsecs = 5
autorestart = true
startretries = 3
user = www-data

以上配置好好, 执行

sudo supervisorctl -c /path/to/supervisord.ini update

就可以让supervisor 守护我们的gunicorn 服务了

状态查看

sudo supervisorctl -c /path/to/supervisord.ini status

可以看到

gunicorn             RUNNING   pid 35640, uptime 0:00:14

状态是running

总结

以上, 我们实现了线上python服务的基础架构部署, 主要是针对python服务的部署, 基本遵循了文首的架构图

以上是我们在项目中实践的架构部署, 欢迎各位一起交流