Linux 集群概念 , wsgi , Nginx负载均衡实验 , 部署CRM(Django+uwsgi+nginx), 部署学城项目(vue+uwsgi+nginx)

Linux 集群概念 , wsgi , Nginx负载均衡实验 , 部署CRM(Django+uwsgi+nginx), 部署学城项目(vue+uwsgi+nginx)

一丶集群和Nginx反向代理

集群的概念:

集群的特性:

Nginx的反向代理

# 反向代理
	# 通过访问Nginx的web服务,由Nginx  对 '有效的请求' 进行一个请求转发,请求到真正的web服务后台数据.返回给用户.

# 正向代理
	# vpn . 访问外国的网站,需要把你的请求进行伪装/代理进行转发

### 如下图~~:

二丶Wsgi

### Wsgi简介:
	WSGI是Web服务器网关接口。它是一个规范，描述了Web服务器如何与Web应用程序通信，以及Web应用程序如何链接在一起以处理一个请求，（接收请求，处理请求，响应请求）

# 基于wsgi运行的框架有bottle,DJango,Flask,用于解析动态HTTP请求

# 支持WSGI的服务器
    1.wsgiref
        python自带的web服务器
    2.Gunicorn
        用于linux的 python wsgi Http服务器，常用于各种django，flask结合部署服务器。
    3.mode_wsgi
        实现了Apache与wsgi应用程序的结合
    4.uWSGI
        C语言开发，快速，自我修复，开发人员友好的WSGI服务器，用于Python Web应用程序的专业部署和开发。

### 结论:
	在部署python程序web应用程序时，可以根据性能的需求，选择合适的wsgi server，不同的wsgi server区别在于并发支持上，有单线程，多进程，多线程，协程的区别，其功能还是近似，无非是请求路由，执行对应的函数，返回处理结果。

Django部署

### Django部署

	# 1. Django的主要部署平台是 WSGI，这是用于Web服务器和应用程序的Python标准。

	# 2. Django的 startproject管理命令设置一个简单的默认WSGI配置，可以根据需要为您的项目进行调整，并指示任何符合WSGI的应用程序服务器使用。

# application
	# 3. 使用WSGI部署的关键概念是应用程序服务器用于与代码通信的 application 可调用。它通常在服务器可访问的Python模块中作为名为 application 的对象提供。

	# 4. startproject 命令创建包含这样的 application 可调用的文件 <project_name>/wsgi.py. ，它被Django的开发服务器和生产WSGI部署使用。

    # 5. WSGI服务器从其配置中获取 application 可调用的路径。 Django的内置服务器，即 runserver 命令，从 WSGI_APPLICATION 设置读取它。

三丶Nginx负载均衡

Nginx的优点

# 1. Web服务器，直接面向用户，往往要承载大量并发请求，单台服务器难以负荷，我使用多台WEB服务器组成集群，前端使用Nginx负载均衡，将请求分散的打到我们的后端服务器集群中，
# 2. 实现负载的分发。那么会大大提升系统的吞吐率、请求性能、高容灾

# 特点:
    Nginx要实现负载均衡需要用到proxy_pass代理模块配置

    Nginx负载均衡与Nginx代理不同地方在于

    Nginx代理仅代理一台服务器，而Nginx负载均衡则是将客户端请求代理转发至一组upstream虚拟服务池

    Nginx可以配置代理多台服务器，当一台服务器宕机之后，仍能保持系统可用。

upstream配置

# 在 nginx.conf > HTTP 区域中配置如下内容:

	upstream django {
       server 10.0.0.10:8000;
       server 10.0.0.11:9000;
	}

# 在nginx.conf > http 区域 >  server区域  > location配置中

# 添加proxy_pass
location / {
            root   html;
            index  index.html index.htm;
            proxy_pass http://django;
}

upstream分配策略

​ upstream默认按照轮训方式负载，每个请求按时间顺序逐一分配到后端节点。

# weight权重
    upstream django {
           server 10.0.0.10:8000 weight=5;
           server 10.0.0.11:9000 weight=10;#这个节点访问比率是大于8000的
    }

# ip_hash IP哈希
    # 每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器

    upstream django {
           ip_hash;
           server 10.0.0.10:8000;
           server 10.0.0.11:9000;
    }

# 注意:IP哈希和权重不一起使用

# backup  在非backup机器繁忙或者宕机时，请求backup机器，因此机器默认压力最小

upstream django {
       server 10.0.0.10:8000 weight=5;
       server 10.0.0.11:9000;
       server node.oldboy.com:8080 backup;
}

​ Nginx负载均衡实验

# 1. 实验环境划分
	角色            ip                    主机名
    lb01        192.168.119.10        lb01
    web01        192.168.119.11        web01
    web02        192.168.119.12        web02

# 2. 关闭防火墙
    iptables -F
    sed  -i 's/enforcing/disabled/' /etc/selinux/config

    systemctl stop firewalld
    systemctl disable firewalld

# 3. web01服务器配置nginx，创建index.html
    server {
            listen       80;
            server_name  192.168.119.11;
            location / {
            root /node;
                index  index.html index.htm;
            }
    }

    mkdir /node
    echo 'i am web01' > /node/index.html

    # 启动NGINX
    ./sbgin/nginx

# 4. web02服务器配置nginx,创建index.html
	server {
    listen       80;
    server_name  192.168.119.12;
    location / {
        root /node;
        index  index.html index.htm;
    }

    mkdir /node
    echo 'i am web02...' > /node/index.html
    #启动nginx
    ./sbing/nginx	

# 5. 配置lb01服务器的nginx负载均衡
	# 5.1 配置nginx.conf
		http {
            include       mime.types;
            default_type  application/octet-stream;
            sendfile        on;
            keepalive_timeout  65;
            upstream node {
              server 192.168.119.11:80;
              server 192.168.119.12:80;
            }
          server {
                    listen       80;
                    server_name 192.168.119.10;
                    location / {
                      proxy_pass http://node;
                      include proxy_params;  #需要手动创建
                    }
                }
            }

# 6.手动创建proxy_params文件，文件中存放代理的请求头相关参数
    [root@lb01 conf]# cat /opt/nginx/conf/proxy_params
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

        proxy_connect_timeout 30;
        proxy_send_timeout 60;
        proxy_read_timeout 60;

        proxy_buffering on;
        proxy_buffer_size 32k;
        proxy_buffers 4 128k;

    启动lb01负载均衡nginx服务
    ./sbin/nginx

#### 总结:
     # 1. 一台机器做后端服务,一台机器搭建nginx环境.
     # 2. 修改nginx机器的配置
        	### 配置负载均衡池
                upstream  mys23server {
                    #默认负载算法是 轮询方式
                    server   192.168.13.70;
                    server 192.168.13.117;
                }
       		### 配置server 虚拟主机
        	    server {
                    listen       80 default_server;
                    server_name  _;
                    #当请求时 192.168.13.64:80/的时候，就进入如下的location
                    location / {
                    #请求转发参数 proxy_pass
                    # proxy_pass是基于http协议的请求转发
                    # uwsgi_pass 结合python的uWSGI服务器，进行协同工作的
                    proxy_pass    http://mys23server; # 配置请求转发的目标地址
                    }
                }

nginx负载均衡调度算法

# 调度算法   　　 概述
    轮询    　　　　按时间顺序逐一分配到不同的后端服务器(默认)
    weight  　　   加权轮询,weight值越大,分配到的访问几率越高
    ip_hash   　　 每个请求按访问IP的hash结果分配,这样来自同一IP的固定访问一个后端服务器
    url_hash   　  按照访问URL的hash结果来分配请求,是每个URL定向到同一个后端服务器
    least_conn     最少链接数,那个机器链接数少就分发

# 注意:
	1.轮询(不做配置，默认轮询)

    2.weight权重(优先级)

    3.ip_hash配置，根据客户端ip哈希分配，不能和weight一起用

nginx动静分离负载均衡

# 分配:
系统                 			服务                软件                ip地址
centos7(lb01)                负载均衡            nginx proxy        192.168.119.10
centos7(web01)                静态资源            nginx静态资源        192.168.119.11
centos7(web02)                动态资源            django            192.168.119.12

四丶为什么要用nginx,uwsgi部署项目

# 1. 首先nginx 是对外的服务接口，外部浏览器通过url访问nginx,

# 2. nginx 接收到浏览器发送过来的http请求，将包进行解析，分析url，如果是静态文件请求就直接访问用户给nginx配置的静态文件目录，直接返回用户请求的静态文件，

	如果不是静态文件，而是一个动态的请求，那么nginx就将请求转发给uwsgi,uwsgi 接收到请求之后将包进行处理，处理成wsgi可以接受的格式，并发给wsgi,wsgi 根据请求调用应用程序的某个文件，某个文件的某个函数，最后处理完将返回值再次交给wsgi,wsgi将返回值进行打包，打包成uwsgi能够接收的格式，uwsgi接收wsgi 发送的请求，并转发给nginx,nginx最终将返回值返回给浏览器。

# 3. 要知道第一级的nginx并不是必须的，uwsgi完全可以完成整个的和浏览器交互的流程，但是要考虑到某些情况

	# 3.1 安全问题，程序不能直接被浏览器访问到，而是通过nginx,nginx只开放某个接口，uwsgi本身是内网接口，这样运维人员在nginx上加上安全性的限制，可以达到保护程序的作用。

	# 3.2 负载均衡问题，一个uwsgi很可能不够用，即使开了多个work也是不行，毕竟一台机器的cpu和内存都是有限的，有了nginx做代理，一个nginx可以代理多台uwsgi完成uwsgi的负载均衡。

	# 3.3 静态文件问题，用django或是uwsgi这种东西来负责静态文件的处理是很浪费的行为，而且他们本身对文件的处理也不如nginx好，所以整个静态文件的处理都直接由nginx完成，静态文件的访问完全不去经过uwsgi以及其后面的东西。

### 总结:
	Nginx对处理静态资源有极高的处理能力,减少对真正服务端的请求.可以利用Nginx实现高并发,高可用等.
    uwsgi是比wsgi更牛逼的网关接口.性能比wsgi更好.

五丶搭建环境(nginx,nodejs)

# 1.安装组件依赖
	yum install zlib-devel bzip2-devel pcre-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel

# 2.配置yum源仓库
	# 1. 进入yum源仓库
    	cd /etc/yum.repo.d

    # 2. 删除仓库里的内容/不删也可以
    	rm -rf ./*
    # 3. 进入阿里yum源 https://opsx.alibaba.com/mirror
    	wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
         wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo

# 3. 安装nginx
	yum install nginx -y

	#  启动nginx
		nginx

# 4. 安装nodejs
    1.下载node源码
        wget https://nodejs.org/download/release/v8.6.0/node-v8.6.0-linux-x64.tar.gz
    2.解压缩，由于这是编译好的二进制命令压缩包，直接配置环境变量即可使用
    3.配置PATH
        PATH="/opt/python367/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/root/bin:/opt/tngx232/sbin:/opt/luffys23/node-v8.6.0-linux-x64/bin"
    4.读取/etc/profile ，手动生效
    5.查看node和npm的版本，是否正常
        [root@s23_linux bin]# node -v
        v8.6.0
        [root@s23_linux bin]# npm -v
        5.3.0

六丶crm部署流程

crm部署流程

第一步.启动mariadb数据库
    1.yum
    配置yum源
    yum install  mariadb-server  mariadb -y  

    2.通过yum安装的软件，怎么启动
    systemctl  start/stop/status/restart mariadb  

    3.登陆数据库

    2.导出windows的数据库，导入给linux机器

    导出命令
    mysqldump  -uroot -p  se_crm >  se_crm.sql  #指定数据库导出到se_crm.sql这个数据文件中

    传输到linux中，进行导入
    简单的利用 lrzsz工具传输
    或者下载xftp工具

    导入数据的命令 

    方式1：
    1.创建一个se_crm数据库
    create  database  se_crm;
    #导入数据的命令
    mysql -uroot -p  se_crm <  /opt/se_crm.sql   #指定se_crm数据库，导入一个sql文件 

    方式2：
    登陆数据库之后，用命令导入数据
        1.创建一个se_crm数据库
            create  database  se_crm;
        2.切换数据库
            use  se_crm;
        3.读取sql文件，写入数据集
          mareiadb>    source /opt/se_crm.sql; 

第二步：准备python3环境，以及虚拟环境
    1.编译安装python3，解决环境变量

    2.下载virtualenvwrapper工具 

    3.使用mkvirtualenv命令，创建新的虚拟环境，用于启动crm

        mkvirtualenv  s23_crm

    4.拷贝crm代码，到linux机器

    5.解决crm运行所需的依赖环境，django等模块，以及pymysql
        解决办法1：
        笨办法，一个个报错去看，去解决 

            pip3 install -i https://pypi.douban.com/simple django==1.11.23
            pip3 install -i https://pypi.douban.com/simple pymysql
            pip3 install -i https://pypi.douban.com/simple django-multiselectfield
            pip3 install -i https://pypi.douban.com/simple django==1.11.23

        不那么笨的办法：
        导出python解释器模块的命令
        pip3 freeze > requirements.txt    #这个  requirements.txt文件是python程序员都认识的模块依赖文件

        安装这个requirements.txt文件中所有的模块 

        pip3 install -r requirements.txt  #指定依赖文件安装，读取文件中所有的模块信息

第三步：

安装uwsgi

    1.通过pip3安装
    pip3 install -i https://pypi.douban.com/simple   uwsgi 

    2.通过uwsgi命令去启动django
        启动方式1（只是练习用）：  通过命令和参数形式
        语法是：
            uwsgi  --http :8000  --module  项目名.wsgi
                    --http指定http协议启动socket服务端，可以通过浏览器直接访问
                    --module  是找到crm项目第二级目录下的wsgi.py 文件 

            uwsgi --http :8000  --module  se_crm.wsgi  

        启动方式2（通过配置文件方式启动，线上是这么使用的）
        uwsig的配置文件 uwsgi.ini  

        1.创建配置文件
        touch  uwsgi.ini 

        2.写入如下内容 uwsgi.ini内容如下 

            [uwsgi]
            # Django-related settings
            # the base directory (full path)
            # 填写crm项目的绝对路径，第一层
            chdir           = /opt/crms23/se_crm

            # Django's wsgi file
            #填写crm项目第二层目录中的wsgi文件
            module          = se_crm.wsgi

            # the virtualenv (full path)
            #填写解释器的安装绝对路径（虚拟环境）
            home            = /root/Envs/s23_crm

            # process-related settings
            # master
            master          = true
            # maximum number of worker processes
            #指定uwsgi的多进程数量，指定为cpu的核数即可（填cpu的4倍数量）
            processes       = 4

            # the socket (use the full path to be safe
            #指定crm启动的协议，当你和nginx结合进行反向代理，就用unix-socket协议 ，这种方式无法直接访问，只能通过nginx反代
            socket          = 0.0.0.0:8000

            #指定http协议启动，不安全，没有意义，只是自己调试使用
            #http =  0.0.0.0:8000

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

        指定uwsgi.ini配置文件启动 

        uwsgi  --ini  uwsgi.ini   # 参数 --ini是指定文件的意思 

        3.收集django的所有静态文件，丢给nginx去处理
        打开 django的settings.py，修改为如下行
            STATIC_ROOT='/opt/crms23/crmstatic/'        #加上这个参数就行了
            STATIC_URL = '/static/'
            STATICFILES_DIRS = [
            os.path.join(BASE_DIR, 'static')
            ]

        ### 通过命令收集django的所有静态文件
        python3  manage.py collectstatic  

第四步：启动nginx，配置反向代理

    1.安装nginx 

    2.修改配置文件 nginx.conf  ，
    注意server{}多虚拟主机是自上而下的加载顺序
    因此修改第一个server{}虚拟主机，修改为如下反代的写法

    且添加nginx处理django的静态文件方式
            server {
                #nginx监听的地址
                listen       80;
                #定义网站的域名
                server_name  www.s23lol.com;

                #charset koi8-r;
                #nginx的url匹配 , /这个斜杠就代表这样的请求：  192.168.13.117:85/
                #这个是最低级匹配，所有的请求都会进入location，进行处理
                #好比 http://192.168.13.117/crm/login/
                location / {
                    #基于uwsgi协议的请求转发，给后端django的启动地址
                    uwsgi_pass 0.0.0.0:8000;    #这个是请求转发
                    include  uwsgi_params;      #这个是添加一个文件，添加请起头信息的
                }
                #我现在想处理这样的请求
                #我可以这样做
                #当以后请求是从static开始，我就让他去这个目录去找
                #http://192.168.13.117/static/css/reset.css
                #不加斜杠
                location  /static  {
                        alias  /opt/crms23/crmstatic;
                }

            }

七丶vue+uwsgi+nginx部署项目

# https://www.cnblogs.com/pyyu/p/10160874.html

#  流程如下
1.前端搞起(nginx+vue  )
获取代码
wget https://files.cnblogs.com/files/pyyu/07-luffy_project_01.zip

2.解压缩代码，修改vue的提交数据地址，以及编译打包生成 dist

修改这个提交数据的地址js文件
/opt/luffys23/07-luffy_project_01/src/restful/api.js文件 

进行批量替换

sed 处理文件内容的命令

#语法
sed  -i  "s/你想替换的内容/替换之后的内容/g"   文件名    #  s是替换模式，g是global全局替换   -i  将替换结果写入到文件，如果不写-i，只是显示替换后的结果 

sed -i "s/127.0.0.1:8000/192.168.13.117:8001/g"  api.js  

3.配置nodejs环境
    1.下载node源码
        wget https://nodejs.org/download/release/v8.6.0/node-v8.6.0-linux-x64.tar.gz
    2.解压缩，由于这是编译好的二进制命令压缩包，直接配置环境变量即可使用
    3.配置PATH
        PATH="/opt/python367/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/root/bin:/opt/tngx232/sbin:/opt/luffys23/node-v8.6.0-linux-x64/bin"
    4.读取/etc/profile ，手动生效
    5.查看node和npm的版本，是否正常
        [root@s23_linux bin]# node -v
        v8.6.0

        [root@s23_linux bin]# npm -v
        5.3.0
4.开始安装vue项目所需的node模块，默认找到当前文件夹的package.json文件 ，这里由于网速问题，可以配置淘宝的npm源
npm --registry https://registry.npm.taobao.org install     #安装vue的模块 

5.编译vue代码，生成dist
npm run build  

6.此时生成dist文件夹之后，可以丢给nginx去解析了

7.配置nginx.conf如下

#配置第二个虚拟主机，返回路飞的首页内容
server {
listen  81;
server_name  _;
#当我访问 192.168.13.117:81的时候，就进入如下的配置
location  /  {
   #定义网页根目录 ，填写vue的dist绝对路径
   root   /opt/luffys23/07-luffy_project_01/dist;
   index   index.html;
}

#第三个虚拟主机，用于反向代理，请求转发给drf后台

server  {
    listen 8001;
    server_name  _;
    location  /  {
    include uwsgi_params;
    uwsgi_pass 0.0.0.0:8002;
    }

}

8.配置drf的后台，提供数据支撑
    获取后台代码
    wget https://files.cnblogs.com/files/pyyu/luffy_boy.zip

    创建新的虚拟环境
    mkvirtualenv luffys23

    解决模块依赖问题
    可以进入本地开发环境，
    pip3 freeze >  requirements.txt
    然后安装这个文件（这就是个普通文本，可以手动写）
    touch requirements.txt
    添加如下内容
certifi==2018.11.29
chardet==3.0.4
crypto==1.4.1
Django==2.1.4
django-redis==4.10.0
django-rest-framework==0.1.0
djangorestframework==3.9.0
idna==2.8
Naked==0.1.31
pycrypto==2.6.1
pytz==2018.7
PyYAML==3.13
redis==3.0.1
requests==2.21.0
shellescape==3.4.1
urllib3==1.24.1
uWSGI==2.0.17.1

9.安装这个文件

pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple  -r requirements.txt 

10.配置uwsgi和配置文件，启动drf
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple    uwsgi  

11.写一个uwsgi.ini配置文件
touch uwsgi.ini 

[uwsgi]
# Django-related settings
# the base directory (full path)
# 填写路飞项目的绝对路径，第一层
chdir           = /opt/luffys23/luffy_boy

# Django's wsgi file
#填写路飞项目第二层目录中的wsgi文件
module          = luffy_boy.wsgi 

# the virtualenv (full path)
#填写解释器的安装绝对路径（虚拟环境）
home            = /root/Envs/luffys23  

# process-related settings
# master
master          = true
# maximum number of worker processes
#指定uwsgi的多进程数量，指定为cpu的核数即可（填cpu的4倍数量）
processes       = 4

# the socket (use the full path to be safe
#指定crm启动的协议，当你和nginx结合进行反向代理，就用unix-socket协议 ，这种方式无法直接访问，只能通过nginx反代
socket          = 0.0.0.0:8002

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

12.启动drf后端
uwsgi --ini uwsgi.ini 

13.登陆路飞
账号密码

alex
alex3714 

14.安装redis数据库，可以用于购物车功能

yum install redis -y  

15.启动redis
systemctl start redis 

16.验证登陆redis
[root@s23_linux ~]# redis-cli
127.0.0.1:6379> ping
PONG

17.检查redis的key信息

127.0.0.1:6379> keys *
(empty list or set)

18.解决路飞首页刷新404问题的办法
    server {
    listen  81;
    server_name  _;
    #当我访问 192.168.13.117:81的时候，就进入如下的配置
    location  /  {
       #定义网页根目录
       root   /opt/luffys23/07-luffy_project_01/dist;
       index   index.html;
       try_files $uri $uri/ /index.html;    #这个参数是解决vue刷新404问题的参数
    }

    }