Django+Nginx+uWSGI部署

一、介绍

Django的部署有多种方式,采用Nginx+uWSGI的方式是最常见的一种方式。在这种方式中,将Nginx作为服务器前端,接收Web的所有请求,统一管理请求。Nginx自己处理所有静态请求,所有非静态请求通过uWSGI传递给Django,由Django来进行处理,从而完成一次Web请求。

二、安装配置

环境:Python(3.5.2)、Django(1.11.6)

1. 安装pip

root@787c084a44e4:~# apt-get install -y python3-pip 

2. 安装uWSGI

root@787c084a44e4:~# python3 -m pip install uWSGI 

3. 安装Django

root@787c084a44e4:~# python3 -m pip install Django 

4. 安装Nginx

root@787c084a44e4:~# apt-get install -y nginx 

5. 通过文件配置uwsgi

新建文件/root/web/uwsgi.ini

[uwsgi]
# 监听IP和端口
socket = 127.0.0.1:9090
# 项目主目录
chdir = /root/web/Django
# uwsgi文件路径
module = Django.wsgi:application
# 允许主进程存在
master = True
# 开启的进行数
workers = 1
# 服务器退出时自动清楚环境
vacuum = True
# 设置工作进程请求上限
max-requests = 1000
# 记录主进行的pid
pidfile = /var/uwsgi.pid
# 使进程在后台运行
daemonize = /var/uwsgi.log

6. 配置nginx虚拟主机

新建文件/etc/nginx/sites-

enabled/django.conf
# nginx需要连接的后端代理
upstream django {
    server 127.0.0.1:9090;
}

# 虚拟主机配置
server {
    # 监听端口
    listen 8080;
    # 域名
    server_name 127.0.0.1;
    # 编码
    charset utf-8;
    # 静态文件路径
    location /static {
        alias /root/web/Django/static;
    }
    # 将动态请求转发到uwsgi运行的django程序
    location / {
        uwsgi_pass django;
        include /etc/nginx/uwsgi_params;
    }
}

7. 修改nginx默认运行用户

修改/etc/nginx/nginx.conf文件,user www-data修改为user root

三、验证部署

运行工程

root@787c084a44e4:~/web# uwsgi --ini uwsgi.ini & nginx

访问地址http://127.0.0.1:8080/list,数据和页面css样式正常

未分类

四、异常情况

1. 出现DisabllowedHost

未分类

修改Django/Django/settings.py文件

ALLOWED_HOSTS = ["*"] 

2. 出现静态文件403异常

未分类

Nginx使用www-data用户运行,无web目录读取权限,修改/etc/nginx/nginx.conf文件,user www-data修改为user root

Python Flask 框架 终极部署教程,超详细。Uwsgi+Nginx+mysql+Supervisor+Virtualenv, 基于阿里云默认Linux

我发现网上还没完整详细版本的Flask 部署教程,而我在部署中遇到很多坑,所以在这里写下来,完整的教程以下是部署流程:

处理本地的代码

假设你已经完成了项目的开发,本地已经安装了git,那么首先将你的代码提交到git;

#进项目根目录
pip freeze > requirements.txt  #导flask 全部包,方便新环境下一次性安装。
git init # 之前如果没有做,那么需要做
git add --all #提交所有修改后的文件
git remote add origin http:xxxx.git  #这一步如果之前没做,那么你需要做。
git commmit -w 'first commit'

安装Mysql

现在进入服务器正式开始搭建环境,首先安装mysql.

新鲜出炉的阿里云需要更新下apt.
apt-get update
然后安装mysql, 注意一定记住root 密码,还要在配置文件中设置字符为UTF8!
增加新的数据库,注意名字和你项目的一样,
create database xxx;

安装虚拟环境 Vitualenv

pip install virtualenvwrapper #直接安装虚拟环境容器来顺便安装virtualenv
注意需要先修改环境变量。否则命名无法使用
vim ~/.bashrc   在最底部增加
#这是为了让 WORKON 命令能用。
export WORKON_HOME=$HOME/.virtualenvs
source /usr/local/bin/virtualenvwrapper.sh

然后你需要用 mkvirtualenv xxx   来创建一个叫xxx 的python 虚拟环境
workon xxx #切换到你的虚拟环境
在这个环境里,你可以升级你的python 到python3, 当然根据你的需求。

安装 Git 拿到全部源码

现在在服务器上安装git 拿到源码
apt install git
git init
git remote add origin http:xxx.git
git pull origin master # 拿到全部源码

正式部署源码

进去项目根目录:
pip install -r requirements.txt  #导入你项目的flask 依赖
pip manager.py db migerate #初始化数据库  
# 这里如果出现初始化失败,那么清空你的 migration 文件夹,你会丢掉你的测试数据,当然有不丢的办法
pip manager.py db upgrade #导入数据库,代码迁移完成

安装Nginx

apt install nginx #安装nginx 
贴下配置文件位于: /etc/nginx/conf.d/xxx.conf
# 配置nginx与uwsgi的通信方式和名称,mysite就是名称
upstream xxx {
    # nginx使用socket的方式与uwsgi进行通信
    # 这里指向你项目的目录下的socket文件,
    # 这个socket文件不需要单独创建,在运行的时候会自动创建。
    server unix:///srv/xxx/xxx.sock;
}
# 配置服务器
server {
    # 监听的端口号
    listen 80;
    # 域名或者本机的ip地址
    server_name dev.wudizu.com 47.104.22.138;
    charset     utf-8;
    # 最大的上传大小
    client_max_body_size 75M;  
    # adjust to taste

    # 访问根目录下的任何url的配置
    location / {
        # 指定访问哪个upstream
        uwsgi_pass wudi;
        # 包括uwsgi参数的文件
        include     /etc/nginx/uwsgi_params;
    }
    location /static {
        alias /srv/xxx/static;
   }

}

安装Uwsgi

pip install uwsgi

贴下配置文件:


[uwsgi]
chdir           = /srv/xxx
# 模块
module          = firstweb   #注意这里一定要你写的flask 首页文件名
# python的虚拟环境
home            = /root/.virtualenvs/flask-py2

# 是否启用mater模式
master          = true

# 进程数
processes       = 10

# socket文件地址

socket          = /srv/xxx/xxx.sock

# wsgi文件

wsgi-file       = /srv/xxx/xxx.ini

# wsgi文件中的app变量

callable        = app

# socket文件的权限

chmod-socket    = 666

安装Supervisor

sudo pip install supervisor
# supervisor的程序名字
[program:mysite]
# supervisor执行的命令
command=uwsgi --ini mysite_uwsgi.ini
# 项目的目录
directory = /srv/xxx 
# 开始的时候等待多少秒
startsecs=0
# 停止的时候等待多少秒
stopwaitsecs=0# 自动开始
autostart=true
# 程序挂了后自动重启
autorestart=true
# 输出的log文件
stdout_logfile=/srv/xxx/log/supervisord.log
# 输出的错误文件
stderr_logfile=/srv/xxx/log/supervisord.err

[supervisord]
# log的级别
loglevel=info

# 使用supervisorctl的配置
[supervisorctl]
# 使用supervisorctl登录的地址和端口号
serverurl = http://127.0.0.1:9001

# 登录supervisorctl的用户名和密码
username = admin
password = 123

[inet_http_server]
# supervisor的服务器
port = :9001
# 用户名和密码
username = admin
password = 123

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface


然后使用supervisor运行uwsgi:
supervisord -c supervisor.conf

使用supervisorctl管理supervisord:supervisor是一个C/S模型,跟redis一样,有一个服务器,也有一个客户端命令用来管理服务的,使用以下命令进入到命令界面:
supervisorctl -c supervisor.conf

指定的文件必须和supervisord服务端保持一致。 一些常用的命令有:
supervisorctl -c supervisor.conf
> status    # 查看状态
> start program_name # 启动程序
> restart program_name # 重新启动程序
> stop program_name # 停止程序
> reload # 重新加载配置文件
> quit # 退出当前的客户端

Nginx+uWSGI+Mysql+Django+Virtualenv环境部署

安装软件包

我的Linux是Ubuntu,需要安装Python3,如果你需要安装其他版本替换即可

sudo apt-get install mysql-server python3 python-dev python3-pip virtualenv

配置Virtualenv及Python环境

首先,这个Virtualenv并不是必须的,他的作用就是创建一个“隔离”的Python运行环境。

我想大家都碰到过在一台电脑上同时开发多个应用程序,如果应用A需要Python 2.7,而应用B需要Python 2.6怎么办?有时还会碰到不只是Python版本的不一致,比如Django等软件包版本。

这种情况下,每个应用可能需要各自拥有一套“独立”的Python运行环境。

1、新建独立运行环境,命名为pyblog_env

virtualenv pyblog_env --python=python3.5 --no-site-packages

–python指定Python版本 –no-site-packages不复制系统已安装Python包

2、进入pyblog_env环境

source pyblog_env/bin/activate

这时会发现命令提示符前面多了一个(pyblog_env),变成(pyblog_env)user@hostname:~$ 这种形式,这表示我们已经进入到刚刚创建的虚拟环境。 然后再通过pip安装包,都会安装到这个环境下,不会对系统环境造成影响。 退出虚拟环境命令:deactivate

3、安装项目依赖

pip3 install django PyMySQL mysqlclient Pillow
#如果有需求文件,比如requirements.txt,则执行
pip3 install -r requirements.txt

Django项目配置

1、上传Django项目,我的项目在GitHub。

git clone https://github.com/zytx/pyblog.git

2、配置项目的数据库信息

3、数据迁移

python manage.py makemigrations
python manage.py migrate

4、建立超级用户:

python manage.py createsuperuser

5、收集静态文件:

python manage.py collectstatic

6、测试项目 运行开发服务器看项目能否正常运行

python manage.py runserver 0.0.0.0:8000

访问ip:8000看是否出错

uWSGI 配置

退出刚才进入的虚拟环境,使用命令:deactivate

1、安装uWSGI

pip3 install uwsgi

2、运行测试:

uwsgi --http :8000 --home /home/zytx/pyblog_env/ --chdir /home/zytx/pyblog_env/pyblog -w pyblog.wsgi

–home Virtualenv的虚拟环境目录 –chdir Django项目目录

如果访问IP:8000可以看到项目,就说明Python环境和uWSGI是没有问题的

3、创建配置文件 接下来在项目里新建一个配置文件uwsgi.ini

[uwsgi]
# 项目根目录路径(full path)
chdir           = /home/zytx/pyblog_env/pyblog/
# Django的 wsgi 文件
module          = pyblog.wsgi:application
# virtualenv目录 (full path)
home            = /home/zytx/pyblog_env/

master          = true
# 最大工作进程数(CPU密集型建议设为CPU核心数,IO密集型建议设为CPU核心数的两倍)
processes       = 2
# unix套接字文
socket          = /home/zytx/pyblog_env/pyblog.sock
# socket文件权限
chmod-socket    = 777
# 退出时清空环境
vacuum          = true

4、后台启动uWSGI

uwsgi /home/zytx/pyblog_env/pyblog/uwsgi.ini&

Nginx 配置

1、创建配置文件

sudo vi /etc/nginx/sites-available/pyblog

加入如下内容:

server {
    listen 80;
    server_name www.immrz.com;
    root /home/zytx/pyblog_env/pyblog/;

        location /media/  {
            #如果你的media目录不在root里,可以配置 alias /path/to/your/mysite/media;
        }

        location  /static/ {
            #如果你的static目录不在root里,可以配置 alias /path/to/your/mysite/static;
        }

        location / {
            uwsgi_pass  unix:///home/zytx/pyblog_env/pyblog.sock;
            include uwsgi_params; # the uwsgi_params file you installed
        }
}

软连接到sites-enabled

sudo ln -s /etc/nginx/sites-available/pyblog /etc/nginx/sites
enabled/

2、重新加载Nginx配置

sudo service nginx reload

如果配置无误我们就可以让uWSGI开机运行

#编辑/etc/rc.local,在exit0之前加入
/usr/local/bin/uwsgi --ini /home/zytx/pyblog_env/pyblog/pyblog.uwsgi.ini&

ubuntu16.04使用nginx、uwsgi部署django应用

安装相关软件

更新源

sudo apt-get update 
sudo apt-get upgrade

安装虚拟环境

sudo apt-get install Python-virtualenv

安装nginx

sudo apt-get install nginx

安装uwsgi

sudo pip3 install uwsgi

或者

sudo pip3 install https://projects.unbit.it/downloads/uwsgi-lts.tar.gz

安装uwsgi出错就安装

sudo apt-get install python-dev 
sudo apt-get install python3.5-dev

本文用到的软件环境

  • ubuntu 16.04
  • Python 3.5.2
  • Django 1.11.4
  • nginx 1.10.3
  • uwsgi 2.0.15

创建一个普通用户

创建用户组webapps

sudo groupadd –system webapps

创建用户user_test并设置密码

sudo useradd –system –gid webapps –shell /bin/bash –home /webapps/test user_test

passwd user_test

创建用户目录并修改目录权限

mkdir -p /webapps/test

chown user_test /webapps/test/

添加用户user_test sudo权限

在/etc/sudoers添加

user_test ALL=(ALL:ALL) ALL

创建测试应用

切换用户为user_test

su - user_test

cd /webapps/test

创建python虚拟环境,这里指定为3.5版本,并激活

virtualenv -p /usr/bin/python3.5 .

source bin/activate

安装django

pip install django

创建django工程mysite

django-admin startproject mysite

创建应用app

cd mysite

django-admin startapp app

修改mysite/settings.py

将外网ip添加到ALLOWED_HOSTS

ALLOWED_HOSTS = ['xxx.xxx.xxx.xxx', '127.0.0.1']

在INSTALLED_APPS里追加 ‘app’

新建app/static目录

在mysite/settings.py里添加

STATIC_ROOT = os.path.join(BASE_DIR, 'app', 'static')

收集静态文件到app/static目录

python manage.py collectstatic

迁移数据库

python manage.py migrate

创建后台管理用户

python manage.py createsuper

添加视图函数

在app/views.py添加

from django.http import HttpResponse
def index(request):
    return HttpResponse('<h1>Hello World!</h1>')

在mysite/urls.py添加

from app import views
urlpatterns = [
    ...
    url(r'^$', views.index),
]

测试django应用运行是否正常

python manage.py runserver

使用curl命令访问

curl 127.0.0.1:8000

正常会输出 <h1>Hello World!</h1>

Ctrl C 退出

当前所涉及的一些目录

  • 用户目录:/webapps/test
  • 虚拟环境目录: /webapps/test
  • 工程目录:/webapps/test/mysite

配置ngnix

从https://github.com/nginx/nginx/blob/master/conf/uwsgi_params下载到/etc/nginx/conf/目录

新建mysite/test_ngnix.conf文件,内容如下

# the upstream component nginx needs to connect to
upstream testapp {
    server unix:///webapps/test/mysite/mysite.sock; # for a file socket
    #server 127.0.0.1:9090; # for a web port socket (we'll use this first)
}

# configuration of the server
server {
    # the port your site will be served on
    listen      80;
    # the domain name it will serve for
    server_name localhost; # substitute your machine's IP address or FQDN
    charset     utf-8;

    # max upload size
    client_max_body_size 75M;   # adjust to taste
    access_log      /webapps/test/mysite/nginx_access.log;
    error_log       /webapps/test/mysite/nginx_error.log;

    # Django media
    location /media  {
        alias /webapps/test/mysite/app/media;  # your Django project's media files - amend as required
    }

    location /static {
        alias /webapps/test/mysite/app/static; # your Django project's static files - amend as required
    }

    # Finally, send all non-media requests to the Django server.
    location / {
        uwsgi_pass  testapp;
        include     /etc/nginx/conf/uwsgi_params; # the uwsgi_params file you installed
    }
}

将test_ngnix.conf链接到/etc/nginx/sites-enabled/目录

sudo ln -s /webapps/test/mysite/test_ngnix.conf /etc/nginx/sites-enabled/

记得删除自带的default文件,否则输入外网ip看到的是ngnix欢迎页

sudo rm /etc/nginx/sites-enabled/default

这里用到的是unix file socket

所以把用户www-data加到webapps用户组,否则读取socket文件时会有权限问题

sudo usermod -a -G webapps www-data

重启ngnix

sudo /etc/init.d/nginx stop 
sudo /etc/init.d/nginx start

配置uwsgi

新建wsgi.ini, 内容如下

[uwsgi]
#socket = 127.0.0.1:9090
chdir=/webapps/test/mysite
module=mysite.wsgi
master = true
processes=2
threads=2
max-requests=2000
chmod-socket=664
vacuum=true
daemonize = /webapps/test/mysite/uwsgi.log
virtualenv = /webapps/test
gid=webapps
uid=user_test
socket = /webapps/test/mysite/mysite.sock

运行uwsgi

uwsgi –ini wsgi.ini

用浏览器访问外网ip,正常会显示Hello World

使用uwsgi Emperor mode

# create a directory for the vassals
sudo mkdir /etc/uwsgi
sudo mkdir /etc/uwsgi/vassals
# symlink from the default config directory to your config file
sudo ln -s /webapps/test/mysite/wsgi.ini /etc/uwsgi/vassals/
# run the emperor
sudo uwsgi --emperor /etc/uwsgi/vassals --uid user_test --gid webapps

Ubuntu安装配置uWSGI Nginx部署Flask项目

关于 uWSGI ,可以先看这篇文章。简单来说,WSGI 是一个 Python 协议,定义了应用程序(我们写的软件)如何与 Web 服务器(如 Nginx)通信,WSGI 只是一个接口。而 uWSGI 是一个支持多种语言的服务器容器,使用 WSGI 定义的标准实现与多种 Web 服务器的通信,并将 Web 服务器发来的请求“翻译”成应用程序所能理解形式。

安装

Python 2:

sudo apt-get update
sudo apt-get install python-pip python-dev nginx

Python 3:

sudo apt-get update
sudo apt-get install python3-pip python3-dev nginx

安装 Flask 和 uwsgi:

pip install uwsgi flask

创建一个简单的 Flask 项目 ~/myproject/myproject.py:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "<h1 style='color:blue'>Hello There!</h1>"

if __name__ == "__main__":
    app.run(host='0.0.0.0')

创建启动文件为 ~/myproject/run.py:

from myproject import app

if __name__ == "__main__":
    app.run()

运行 python run.py ,然后访问 http://server_domain_or_IP:5000 将会看到:

未分类

当然直接使用 python run.py 的方法只适合本地开发,线上的话速度太慢,我们需要使用 uwsgi。

uwsgi

首先确保你安装了 uwsgi,然后运行:

uwsgi --socket 0.0.0.0:5000 --protocol=http -w run:app

protocol 说明使用 http 协议,-w 指明了要启动的模块,run 就是项目启动文件 run.py 去掉扩展名,app 是 run.py 文件中的变量 app,即 Falsk 实例。然后访问 http://server_domain_or_IP:5000,同样会看到上图。说明 uwsgi 可以正常运行。

但是这样的话每次都从命令行启动太麻烦,可以在 ~/myproject/目录下创建一个配置文件 myproject.ini:

[uwsgi]
module = run:app
master = true
processes = 3

chdir = /home/ubuntu/myproject
socket = /path/to/sock/myproject.sock
logto = /home/to/log/ishuhui.log
chmod-socket = 660
vacuum = true
  • processes = 5 说明要启动5个子进程处理请求;module = run:app 和命令行使用的意义一样;
  • chdir = /home/ubuntu/myproject 只想我们项目的根目录,即 run.py 所在文件夹;
  • socket = /path/to/sock/myproject.sock 是 uwsgi 启动后所需要创建的文件,这个文件用来和 Nginx 通信,后面会在配置 Nginx 时用到,所以 chmod-socket = 660 是为了修改 .sock 文件权限来和 Nginx 通信;
  • logto = /home/to/log/ishuhui.log 指明了 uwsgi 日志目录,uwsgi 会将请求历史写入该文件。

配置完成后运行:

uwsgi --ini myproject.ini

可以看到 /path/to/sock/myproject.sock 目录下多了 myproject.sock 文件,用来和 Nginx 通信。接下来配置 Nginx。

配置 Nginx

配置 Nginx 特别简单,找到 Nginx 配置文件(sudo vim /etc/nginx/sites-available/default),修改为如下格式:

server {
    listen 80;
    server_name server_domain_or_IP;

    location / {
        include uwsgi_params;
        uwsgi_pass unix:/path/to/sock/myproject.sock;
    }
}

其实重要的就两行:

include uwsgi_params;
uwsgi_pass unix:/path/to/sock/myproject.sock;

接下来不出意外,访问 80 端口,就可以看到你的程序了。

将 uwsgi 设置为系统服务

我们运行 uwsgi –ini myproject.ini 之后,按 ctrl+c 或者关闭 ssh 连接窗口,都会导致 uwsgi 进程关闭。 uwsgi 进程一关闭,.sock 文件就会消失,这时访问网站 Nginx 就会报错:

未分类

这时,我们需要进程管理软件管理 uwsgi 进程的运行了。Ubuntu 自带的 systemd 是最简单的方法,可以将我们的项目变为系统服务。首先创建 myproject.service 文件 sudo vim /etc/systemd/system/myproject.service:

[Unit]
Description=uWSGI instance to serve myproject
After=network.target

[Service]
User=lufficc
Group=www-data
WorkingDirectory=/home/ubuntu/myproject
Environment=FLASKR_SETTINGS=/home/ubuntu/myproject/env.cfg
ExecStart=/usr/local/bin/uwsgi --ini /home/ubuntu/myprojectenv/ishuhui.ini

[Install]
WantedBy=multi-user.target
  • WorkingDirectory: 你的项目目录。
  • Environment:需要的环境变量,比如指明你的项目的配置文件。
  • ExecStart:服务启动的代码。
  • WantedBy=multi-user.target:指明会跟随系统启动而启动该服务。

注意以上所有路径为绝对路径。

接下来可以愉快的启动了(myproject 就是 myproject.service 文件名去掉扩展名):

sudo systemctl start myproject
sudo systemctl restart myproject
sudo systemctl stop myproject

使用nginx virtualenv uWSGI配置django运行环境

升级并安装 pip

sudo apt-get update
sudo apt-get install python-pip

安装虚拟环境

sudo pip install virtualenv virtualenvwrapper

加入到环境变量中

当前用户目录下的 Env为虚拟环境存放的目录

echo "export WORKON_HOME=~/Env" >> ~/.bashrc
echo "source /usr/local/bin/virtualenvwrapper.sh" >> ~/.bashrc

激活配置

source ~/.bashrc

创建虚拟环境

环境名为:firstsite

在用户当前目录下创建 Django工程

cd ~
django-admin.py startproject firstsite

django 的初始化

cd ~/firstsite
./manage.py migrate
./manage.py createsuperuser

Django静态文件配置

nano firstsite/settings.py
STATIC_ROOT = os.path.join(BASE_DIR, "static/")
./manage.py collectstatic

安装 uWSGI

sudo apt-get install python-dev
sudo pip install uwsgi

测试是否能够正常访问 django 项目

  • http 指定进程端口8080
  • home指定虚拟环境目录
  • chdir指定 项目工程所在目录
uwsgi --http :8080 --home /home/pi/Env/firstsite --chdir /home/pi/firstsite -w firstsite.wsgi

创建 uwsgi 的配置文件

sudo mkdir -p /etc/uwsgi/sites
cd /etc/uwsgi/sites

uwsgi 的配置相关内容(重点)

[uwsgi]
project = firstsite
base = /home/pi

chdir = %(base)/%(project)
home = %(base)/Env/%(project)
module = %(project).wsgi:application

master = true
processes = 5

socket = %(base)/%(project)/%(project).sock
chmod-socket = 666
vacuum = true

启动守护进程

vim /etc/systemd/system/uwsgi.service

[Unit]
Description=uWSGI Emperor service
After=syslog.target

[Service]
ExecStart=/usr/local/bin/uwsgi --emperor /etc/uwsgi/sites
Restart=always
KillSignal=SIGQUIT
Type=notify
StandardError=syslog
NotifyAccess=all

[Install]
WantedBy=multi-user.target

重载守护进程的配置信息

sudo systemctl daemon-reload

系统重启后uwsgi守护进程自动重启

sudo systemctl enable uwsgi

启动uwsgi进程

sudo systemctl start uwsgi

nginx 的安装

sudo apt-get install nginx

nginx的配置

sudo nano /etc/nginx/sites-available/firstsite
server {
    listen 80;
    server_name firstsite.com www.firstsite.com;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/pi/firstsite;
    }

    location / {
        include         uwsgi_params;
        uwsgi_pass      unix:/home/pi/firstsite/firstsite.sock;
    }
}

nginx配置生效

sudo ln -s /etc/nginx/sites-available/firstsite /etc/nginx/sites-enabled

检查配置

sudo service nginx configtest

重启nginx

sudo service nginx restart

非 debug 模式

非 debug 模式需要重启uwsgi 服务

sudo systemctl restart uwsgi

配置nginx uwsgi部署Django项目

概念

  • Nginx:
    是一款面向性能设计的HTTP服务器,相较于Apache、lighttpd具有占有内存少,稳定性高等优势

  • uwsgi:
    是一个Web服务器,它实现了WSGI协议、uwsgi、http等协议。Nginx中HttpUwsgiModule的作用是与uWSGI服务器进行交换。

  • 运行过程:
    nginx作为服务器的最前端,它将接受WEB的所有请求,统一管理请求。nginx把所有静态请求自己来处理(这是nginx的强项,静态文件像我们django博客项目中的static文件夹下面的图片,css,js)。然后nginx将所有的非静态请求(像显示文章的详细信息,通常这类信息都保存在数据库,因此需要调用数据库获取数据)通过uwsgi传递给Django,由django来处理,从而完成一次WEB请求。uwsgi的作用就类似一个桥接器,起到桥梁的作用。

部署环境

阿里云服务器ubuntu14.04 (域名买了还没备案,所以博客暂时是通过ip访问的)

  • python3.5.2
  • nginx 1.4.6
  • uwsgi 2.0.15
  • django 1.11.3
  • markdown 1.0.1

一:安装nginx

打开putty远程控制云服务器输入账号和密码:

sudo apt-get install update 更新ubuntu库资源
sudo apt-get install nginx  安装nginx:
service nginx restart  启动nginx(重启)这个命令在后面要常用到

访问:http://59.110.155.51(这是我的云服务器的ip)

未分类

出现上图,则说明nginx启动成功

二:安装uwsgi

sudo apt-get install python3-pip
pip3 install uwsgi

测试uwsgi,创建test.py文件(注意:Linux创建目录的命令是:mkdir,创建test.py用 “vi test.py”命令)

def application(env, start_response):
    start_response('200 OK', [('Content-Type','text/html')])
    return [b"Hello World"]

函数名字application,这是默认的函数,uwsgi的Python加载器将会搜索这个名字
把它部署到htto端口8000(现在运行uwsgi来启动一个会把请求传递给你的wsgi应用的http服务器):

uwsgi --http :8000 --wsgi-file test.py

未分类

出现上图,则说明测试成功。

三:从github上获取django项目

sudo apt-get install git 安装git
git clone https://github.com/xuna123/Django_study1.git

四:安装django和markdwon:

pip3 install django
pip3 install markdown

五:将nginx+uwsgi部署到django博客项目

我们实现的目录:

未分类

在我们从Git拉下来Django_study1项目的时候,在子目录下回自动帮我们生成wsgi.py文件,所以我们只需要创建

myweb_uwsgi.ini配置文件。

vim myweb_uwsgi.ini

文件内容:

# Django-related settings

socket = :8000

# the base directory (full path)
chdir           = /root/Django_study1


# Django s wsgi file
module          = easyblog.wsgi

# process-related settings
# master
master          = true

# maximum number of worker processes
processes       = 4

# ... with appropriate permissions - may be needed
# chmod-socket    = 664
# clear environment on exit
vacuum          = true

文件意思:

    • socket :指定项目执行的端口号
    • chadir :指定项目的目录
    • module :可以这么来理解,对于- myweb_uwsgi.ini文件来说,与它的平级的有一个easyblog目录,这个目录下有一个wsgi.py文件
    • master :允许主线程存在(true)
    • processes:开启的进程数量(这里是开启4个进程)
    • vacuum :当服务器退出的时候自动清理环境,删除unix socket文件和pid文件

配置nginx:

接下来要做的就是修改nginx的配置文件,打开/etc/nginx/sites-available/default文件,删除所有内容,写入下面内容:

server {
    listen         8099;
    server_name    59.110.155.51
    charset UTF-8;
    access_log      /var/log/nginx/myweb_access.log;
    error_log       /var/log/nginx/myweb_error.log;

    client_max_body_size 75M;

    location / {
        include uwsgi_params;
        uwsgi_pass 59.110.155.51:8000;
        uwsgi_read_timeout 2;
    }
    location /static {
        expires 30d;
        autoindex on;
        add_header Cache-Control private;
        alias /Django_study1/blog/static;
     }
 }
  • listen 指定的是nginx代理uwsgi对外的端口号(这个要自己阿里云服务器的安全组中添加)

  • server_name : 服务器的名字,(因为暂时没有域名,就写的ip地址)

  • access_log :用来指定日志文件的存放路径

  • error_log :用来指定错误日志文件的存放路径

  • include uwsgi_params “一般来说,你只需包含uwsgi_params文件 (包含在nginx发行版本中),使用uwsgi_pass指令来设置uWSGI socket的地址。

  • uwsgi_pass 设置uwsgi服务器的协议和地址,协议可是uwsgi或suwsgi(uwsgi over ssl); 地址可以是ip地址,域名,和可选的端口。

  • uwsgi_read_timeout:指令的含义是如果视图函数处理的时间超时,uwsgi便会关闭连接,这个关闭只是针对Nginx这边的关闭,视图函数还会继续执行,处理完成后,视图函数那边会报IO写入。

  • expires 30d:意味着静态和媒体文件夹中的所有内容将在30天内由浏览器缓存,但不会删除任何内容,您将无需重新生成服务器中的任何内容。

  • autoindex on;启用目录流量, 默认为off,显示的文件时间为GMT时间。改为on后,显示的文件时间为文件的服务器时间。

  • add_header Cache-Control private: HTTP协议的Cache -Control指定请求和响应遵循的缓存机制。private(默认): 只能在浏览器中缓存, 只有在第一次请求的时候才访问服务器, 若有max-age, 则缓存期间不访问服务器。

  • alias /Django_study1/blog/static; 静态文件的位置(暂时这么理解)

接下里还有 一部修改settings.py里面的8ALLOWED_HOSTS增加我们访问的ip,如下:

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = ['localhost','59.110.155.51']

现在我们重启nginx 和uwsgi:

service nginx restart
uwsgi --ini myweb_uwsgi.ini

未分类

CentOS7系统安装uWSGI Nginx运行Django应用

1. 基础环境配置

先安装好基础环境

cd ~
sudo yum groupinstall "Development tools"
sudo yum install python34 python34-devel python34-pip
pip3 install virtualenv
virtualenv python34
source python34/bin/activate

测试python环境

python --version
pip --version

如果是python3.4的环境,至此python环境配置好了,如果有错,多用一下Google解决。

2. Nginx安装

参考Nginx官网的安装文档,建议新手使用yum安装,后续升级维护方便。

  • 首先要安装Nginx仓库,sudo vi /etc/yum.repos.d/nginx.repo添加以下内容:
[nginx]
name=nginx repo
baseurl=http://nginx.org/packages/centos/7/$basearch/
gpgcheck=1
enabled=1
  • 下载Nginx的key文件,wget https://nginx.org/keys/nginx_signing.key
  • 安装key文件,sudo rpm –import nginx_signing.key
  • 安装Nginx,sudo yum install nginx
  • 测试Nginx,sudo nginx

3. uWSGI安装

从此往下都需要在Python34的虚拟环境下,检查自己是否在Python34虚拟环境下,不在的话执行source python34/bin/activate确认进入虚拟环境,执行pip install uwsgi安装uWSGI,测试uWSGI是否安装好。执行vi test.py输入一下内容保存:

def application(env, start_response):
    start_response('200 OK', [('Content-Type','text/html')])
    return [b"Hello World"]

开启uWSGI服务,uwsgi –http :8000 –wsgi-file test.py,打开浏览器,输入(你的IP):8000看到Hello World代表web client到uWSGI到Python的连接正常。

4. Django配置

先执行pip install -r requirements.txt安装好Python包,正式部署前要配置好Django项目的配置(settings.py),修改一下项目:

DEBUG = False
ALLOWED_HOSTS = ['127.0.0.1','localhost','(你的域名)']
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

然后记得执行一下语句:

python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser # 创建超级用户
python manage.py collectstatic

然后执行python manage.py runserver测试Django项目运行是否正常。

5. uWSGI到Django配置

uwsgi --http :8000 --module (你的Djnago项目名).wsgi

打开浏览器测试(8000端口),如果Django项目运行正常,表示Web Client到uWSGI到Django运行正常。

vi uwsgi.ini添加以下内容并保存

[uwsgi]
socket = :8001
chdir= (你的Django项目地址)
wsgi-file = (你的Django项目地址下wsgi.py所在位置)
touch-reload = ~/reload # 如果reload文件有更改,重启uWSGI
module=(你的Django项目名称).wsgi
master=true
processes = 2 # 进程数
threads = 4 # 线程数
chmod-socket    = 664
chown-socket = (centos用户名):(centos组)
vacuum=true
pidfile = ~/tmp/uwsgi.pid #pid 文件位置

执行uWSGI –ini uwsgi.ini &运行uWSGI,如果Django项目有更改的话可以执行touch ~/reload重启uWSGI。

6. 配置Nginx

执行 sudo vi /etc/nginx/nginx.conf修改添加一下内容

# 注意,这只是nginx.conf中的一部分,其他内容不熟悉的话不要修改。

http {
    upstream django {
        server 127.0.0.1:8001;
    }

    server {
        listen       80;
        server_name  (你的域名地址);
        if ($host != 'www.willtunner.me' ) {
            rewrite ^/(.*)$ http://www.willtunner.me/$1 permanent;
        }   # 此处修改自动添加www

        charset utf-8;
        access_log  logs/host.access.log  main;

        location / {
            uwsgi_pass  django;
            include     /etc/nginx/uwsgi_params;
        }

        location /static/ {
            alias (你的Django项目static地址);
        }

        location /media/ {
            alias (你的Django项目media地址);
        }

        location ~ .*.txt$ {
            root (robots.txt所在地址);
        }
    }
}

当然Nginx虚拟主机配置最好使用include语法放置在其他文件夹下,多个虚拟主机比较好管理,这里我只有一个虚拟主机,故直接在这里修改了。

改好了之后执行sudo nginx -s stop和sudo nginx重新加载Nginx的配置。

没有出错的话,至此从Web Client到Nginx到uWSGi到Django的通路便建立好了。网站可以正常访问了。

Ubuntu系统使用Nginx uWSGI部署Flask应用

我职业生涯的大部分都在使用微软的架构,最近我决定走出技术的舒适区,步入开源软件世界。我现在日常工作的项目是一个RESTful服务,这个服务需要在主流硬件上运行,且能够按照需要进行水平拓展。为完成这项工作我决定使用Flask和Nginx。Flask是一个轻量级的Python Web框架,Nginx是一个非常稳定的Web服务器,它们在廉价硬件平台上工作良好。

在这篇文章中我将指导你完成使用Nginx服务器托管Flask应用的安装、配置过程。我所使用的操作系统是Ubuntu 13.04。

前提条件

在我们开始安装Nginx及其他所需软件之前先安装一些前提软件。首先,我们需要PIP与virtualenv:

sudo apt-get install python-setuptools
sudo easy_install pip
sudo pip install virtualenv

使用apt-get安装Nginx的话,我们需要添加Nginx库到apt-get source中:

sudo add-apt-repository ppa:nginx/stable

注意:如果“add-apt-repository”命令在你的Ubuntu版本中不存在的话,你需要安装“software-properties-common”包,使用命令:sudo apt-get software-properties-common(感谢get_with_it在评论中提到)

升级已有的包,确保系统上有uWSGI所需的编译器和工具:

sudo apt-get update && sudo apt-get upgrade
sudo apt-get install build-essential python python-dev

Nginx

安装并运行Nginx:

sudo apt-get install nginx
sudo /etc/init.d/nginx start

Nginx是一个提供静态文件访问的web服务,然而,它不能直接执行托管Python应用程序,而uWSGI解决了这个问题。让我们先安装uWSGI,稍候再配置Nginx和uWSGI之间的交互。

sudo pip install uwsgi

里程碑 #1

打开浏览器访问你的服务器,你应该能看到Nginx欢迎页:

示例应用

我们将托管的应用是经典的“Hello, world!”。这个应用只有一个页面,已经猜到页面上将有什么内容了吧。将所有应用相关的文件存放在/var/www/demoapp文件夹中。下面创建这个文件夹并在其中初始化一个虚拟环境:

sudo mkdir /var/www
sudo mkdir /var/www/demoapp

由于我们使用root权限创建了这个文件夹,它目前归root用户所有,让我们更改它的所有权给你登录的用户(我的例子中是ubuntu)

sudo chown -R ubuntu:ubuntu /var/www/demoapp/

创建并激活一个虚拟环境,在其中安装Flask:

cd /var/www/demoapp
virtualenv venv
. venv/bin/activate
pip install flask

使用下面的代码创建hello.py文件:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=8080)

里程碑 #2

让我们执行我们刚创建的脚本:

python hello.py

现在你可以通过浏览器访问你服务器的8080端口,看,应用生效了:

注意:因为80端口已被Nginx使用,这里我使用8080端口。

现在应用是由Flask内置的web服务托管的,对于开发和调试这确实是个不错的工具,但不推荐在生产环境中使用。让我们配置Nginx来挑起这个重担吧。

配置Nginx

首先删除掉Nginx的默认配置文件:

sudo rm /etc/nginx/sites-enabled/default

注意:如果你安装了其他版本的Nginx,默认配置文件可能在/etc/nginx/conf.d文件夹下。

创建一个我们应用使用的新配置文件/var/www/demoapp/demoapp_nginx.conf:

server {
    listen      80;
    server_name localhost;
    charset     utf-8;
    client_max_body_size 75M;

    location / { try_files $uri @yourapplication; }
    location @yourapplication {
        include uwsgi_params;
        uwsgi_pass unix:/var/www/demoapp/demoapp_uwsgi.sock;
    }
}

将刚建立的配置文件使用符号链接到Nginx配置文件文件夹中,重启Nginx:

sudo ln -s /var/www/demoapp/demoapp_nginx.conf /etc/nginx/conf.d/
sudo /etc/init.d/nginx restart

里程碑 #3

访问服务器的公共ip地址,你会看到一个错误:

别担心,这个错误是正常的,它代表Nginx已经使用了我们新创建的配置文件,但在链接到我们的Python应用网关uWSGI时遇到了问题。到uWSGI的链接在Nginx配置文件的第10行定义:

uwsgi_pass unix:/var/www/demoapp/demoapp_uwsgi.sock;

这代表Nginx和uWSGI之间的链接是通过一个socket文件,这个文件位于/var/www/demoapp/demoapp_uwsgi.sock。因为我们还没有配置uWSGI,所以这个文件还不存在,因此Nginx返回“bad gateway”错误,让我们马上修正它吧。

配置uWSGI

创建一个新的uWSGI配置文件/var/www/demoapp/demoapp_uwsgi.ini:

[uwsgi]
#application's base folder
base = /var/www/demoapp

#python module to import
app = hello
module = %(app)

home = %(base)/venv
pythonpath = %(base)

#socket file's location
socket = /var/www/demoapp/%n.sock

#permissions for the socket file
chmod-socket    = 666

#the variable that holds a flask application inside the module imported at line #6
callable = app

#location of log files
logto = /var/log/uwsgi/%n.log

创建一个新文件夹存放uWSGI日志,更改文件夹的所有权:

sudo mkdir -p /var/log/uwsgi
sudo chown -R ubuntu:ubuntu /var/log/uwsgi

里程碑 #4

执行uWSGI,用新创建的配置文件作为参数:

uwsgi --ini /var/www/demoapp/demoapp_uwsgi.ini

接下来访问你的服务器,现在Nginx可以连接到uWSGI进程了:

我们现在基本完成了,唯一剩下的事情是配置uWSGI在后台运行,这是uWSGI Emperor的职责。

uWSGI Emperor

uWSGI Emperor (很拉风的名字,是不?) 负责读取配置文件并且生成uWSGI进程来执行它们。创建一个初始配置来运行emperor – /etc/init/uwsgi.conf:

description "uWSGI"
start on runlevel [2345]
stop on runlevel [06]
respawn

env UWSGI=/usr/local/bin/uwsgi
env LOGTO=/var/log/uwsgi/emperor.log

exec $UWSGI --master --emperor /etc/uwsgi/vassals --die-on-term --uid www-data --gid www-data --logto $LOGTO

最后一行运行uWSGI守护进程并让它到/etc/uwsgi/vassals文件夹查找配置文件。创建这个文件夹,在其中建立一个到链到我们刚创建配置文件的符号链接。

sudo mkdir /etc/uwsgi && sudo mkdir /etc/uwsgi/vassals
sudo ln -s /var/www/demoapp/demoapp_uwsgi.ini /etc/uwsgi/vassals

同时,最后一行说明用来运行守护进程的用户是www-data。为简单起见,将这个用户设置成应用和日志文件夹的所有者。

sudo chown -R www-data:www-data /var/www/demoapp/
sudo chown -R www-data:www-data /var/log/uwsgi/

注意:我们先前安装的Nginx版本使用“www-data”这个用户来运行Nginx,其他Nginx版本的可能使用“Nginx”这个替代用户。

由于Nginx和uWSGI都由同一个用户运行,我们可以在uWSGI配置中添加一个安全提升项。打开uWSGI配置文件,将chmod-socket值由666更改为644:

...
#permissions for the socket file
chmod-socket    = 644

现在我们可以运行uWSGI了:

sudo start uwsgi

最后,Nginx和uWSGI被配置成启动后立即对外提供我们的应用服务。

问题解决

如果出现错误的话,第一个检查的地方是日志文件。Nginx默认将错误信息写到/var/log/nginx/errors.log文件。

我们已经配置了uWSGI emperor将日志写到/var/log/uwsgi/emperor.log。这个文件夹还包含着每个配置应用的单独日志。我们的例子是 – /var/log/uwsgi/demoapp_uwsgi.log。

静态文件

如果你的应用提供静态文件的话,将下面的规则添加到demoapp_nginx.conf文件:

location /static {
    root /var/www/demoapp/;
}

上面配置的结果就是所有在/var/www/demoapp/static文件夹中的文件将由提供Nginx对外服务(谢谢Bastianh指出)

托管多个应用

如果你想在一台服务器上托管多个Flask应用,为每个应用创建一个单独的文件夹,像我们前面所做的一样,创建Nginx及uWSGI配置文件到应用文件夹的符号链接。

使用Distribute部署应用

使用distribute部署Flask应用的话,首先,按照Flask文档里的步骤将应用转化成package,然后复制distribute通用安装包到服务器上,使用虚拟环境中的Python来安装它。如下:

python setup.py install

最后且同样重要的是,uwsgi配置里应用属性的值要设置成包含Flask应用的包的名称。

Ubuntu 14.04使用Nginx uWSGI部署Django应用

Django是一个高级的Python Web框架,Django的主要目的是简便、快速的开发数据库驱动的网站。本文介绍了在Ubuntu 14.04上使用uWSGI和nginx部署Django应用程序。

安装nginx, Python工具和uWSGI

1.安装nginx,SQLite Python bindings和管理Python工具所需的系统包:

  1. sudo apt-get install build-essential nginx python-dev python-pip python-sqlite sqlite

2.安装virtualenv和virtualenvwrapper:

  1. sudo pip install virtualenv virtualenvwrapper

virtualenv和virtualenvwrapper是创建隔离的Python环境的工具。 它们有助于更好地管理应用程序依赖性,版本和权限。 要使virtualenvwrapper正常工作,请运行以下命令:

  1. echo "export WORKON_HOME=~/Env" >> ~/.bashrc
  2. echo "source /usr/local/bin/virtualenvwrapper.sh" >> ~/.bashrc

3.在当前会话中激活virtualenvwrapper:

  1. source ~/.bashrc

4.使用pip安装uWSGI:

  1. sudo pip install uwsgi

配置Django应用程序示例

1.确保您在django用户的主目录中并为应用程序创建虚拟环境:

  1. cd /home/django && mkvirtualenv sample

执行此命令后,您的提示将更改为(sample)[email protected]:~$表示您正在使用sample虚拟环境。 要退出虚拟环境,请输入deactivate。
2.安装Django framework

  1. pip install Django

3.创建新的Django应用程序示例,位于/home/django/sample:

  1. django-admin.py startproject sample

4.切换到Django应用程序的目录并初始化SQLite数据库:

  1. cd ~/sample && ./manage.py migrate

5.当使用nginx运行Django时,需要配置Django将所有静态资源放在应用程序的静态文件夹中。 在settings.py中指定其位置:

  1. echo ‘STATIC_ROOT = os.path.join(BASE_DIR, "static/")’ >> sample/settings.py

6.运行以下命令将所有静态资源移动到上述目录中:

  1. ./manage.py collectstatic

7.启动开发服务器以测试示例应用程序:

  1. ./manage.py runserver 0.0.0.0:8080

请在您的浏览器中访问http://example.com:8080,以确认示例应用程序已正确设置并正常工作。 您应该会看到Django测试页。

配置uWSGI

1.创建目录以存放uWSGI配置

  1. sudo mkdir -p /etc/uwsgi/sites

2.创建配置文件sample.ini:
/etc/uwsgi/sites/sample.ini:

  1. [uwsgi]
  2. project = sample
  3. base = /home/django
  4.  
  5. chdir = %(base)/%(project)
  6. home = %(base)/Env/%(project)
  7. module = %(project).wsgi:application
  8.  
  9. master = true
  10. processes = 2
  11.  
  12. socket = %(base)/%(project)/%(project).sock
  13. chmod-socket = 664
  14. vacuum = true

3.为uWSGI创建Upstart job:
/etc/init/uwsgi.conf:

  1. description "uWSGI"
  2. start on runlevel [2345]
  3. stop on runlevel [06]
  4. respawn
  5.  
  6. env UWSGI=/usr/local/bin/uwsgi
  7. env LOGTO=/var/log/uwsgi.log
  8.  
  9. exec $UWSGI –master –emperor /etc/uwsgi/sites –die-on-term –uid django –gid www-data –logto $LOGTO

4.启动uwsgi服务

  1. sudo service uwsgi start

配置Nginx

1.删除默认的nginx站点配置:

  1. sudo rm /etc/nginx/sites-enabled/default

2.为您的Django应用程序创建一个nginx站点配置文件:
/etc/nginx/sites-available/sample:

  1. server {
  2.     listen 80;
  3.     server_name example.com;
  4.  
  5.     location = /favicon.ico { access_log off; log_not_found off; }
  6.     location /static/ {
  7.         root /home/django/sample;
  8.     }
  9.  
  10.     location / {
  11.         include         uwsgi_params;
  12.         uwsgi_pass      unix:/home/django/sample/sample.sock;
  13.     }
  14. }

3.创建指向nginx sites-enabled目录的符号链接以启用站点配置文件:

  1. sudo ln -s /etc/nginx/sites-available/sample /etc/nginx/sites-enabled

4.检查nginx配置并重新启动它:

  1. sudo service nginx configtest && sudo service nginx restart

5.现在,您应该可以通过浏览器输入你的域名或IP地址来访问您的Django应用程序。