20200401 docker部署与mysql主从搭建django读写分离

目录

• 昨日总结
• 1. docker部署django应用
  • 1.1 基于python基础镜像来做
    • 准备镜像
    • 创建目录
    • 创建容器
    • 上传代码
    • 解压
    • 进入容器
    • 安装项目所需依赖
    • 修改项目设置
    • 运行项目
      • 运行项目(wsgiref方式)
      • uwsgi启动
        • 1.安装uwsgi
        • 2.在项目根路径下创建一个uwsgi.ini 文件，写入vim uwsgi.ini
        • 3.启动，停止，重启，查看
        • 4.nginx转发
    • 完整步骤
  • 1.2 基于dockerfile
• 2. mysql主从搭建
  • 原理
  • docker 配置文件
    • 主库
    • 从库
  • 启动容器
  • 远程连接主库从库
    • 连接主库
    • 连接从库
  • 测试主从同步
• 3. django实现读写分离

昨日总结

# 1 容器操作  :从镜像来的---》容器（linux）上装软件
# 2 创建并运行 docker run -di --name=名字 -p 宿主机端口:容器端口 -p 80:8008 -v 宿主机目录：容器目录
# 3 进入容器：attach    docker exec -it 容器id  /bin/bash
# 4 删除，重启，停止
# 5 容器和宿主机copy文件

# 6 把容器打包成镜像----》传到私有仓库
# 7 镜像备份--》打成tar压缩包---》load回来

# 8 dockerfile 一堆命令---》基于一个初始镜像---》构建出镜像---》容器
# 9 用的最多，基于centos/python--》构建出django运行环境
# 10 私有仓库搭建：

# git：你们公司用的什么？github（公司不会用）---》个人或者公司开源用
	-私有仓库：自，公司自己用，别人看不到    https://bitbucket.org/ ，码云（国内，私有仓库，你公司的代码，放到别公司里）
  gitlab（公司自己搭建的git服务器（跟码云，github没有区别））
  公司来新人，创建账号--》分配权限---》，
  -公有仓库：所有人都能看到
  
  
  pipreq

1. docker部署django应用

1.1 基于python基础镜像来做

准备镜像

docker pull python:3.6
docker pull nginx

创建目录

cd /home
mkdir myproject
cd myproject

创建容器

做端口以及目录映射

docker run -di --name=myproject -p 8080:8080 -v /home/myproject:/home python:3.6
# 23a04123bcc6f66903f71819e0692673d6be12089a7d7e422e4e49d332b01391

上传代码

xshell上传文件直接拖拽即可(失败:需要安装lrzsz)
	yum -y install lrzsz
	
远程
scp django_test.zip root@101.133.225.166:/home/myproject

解压

# 解压：uzip （安装）
	yum install -y unzip zip

解压获取源码
	unzip 1227.zip 

进入容器

docker exec -it myproject /bin/bash

安装项目所需依赖

切换到项目目录中,安装所需依赖

cd home
pip install -r requirement.txt
# 自定制的项目所有依赖文件 requirement.txt


查看项目
# pip list

修改项目设置

需要安装
    apt-get update
    apt-get vim
    
vim settings.py

setting.py 改成下面
	ALLOWED_HOSTS = ['*']

运行项目

运行项目(wsgiref方式)

会比较慢,更换成uwsgi

python manage.py runserver 0.0.0.0:8080

uwsgi启动

性能会比wsgiref高很多

1.安装uwsgi

	pip install uwsgi

2.在项目根路径下创建一个uwsgi.ini 文件，写入vim uwsgi.ini

[uwsgi]
#配置和nginx连接的socket连接
socket=0.0.0.0:8080
#也可以使用http
#http=0.0.0.0:8080
#配置项目路径，项目的所在目录
chdir=/home/django_test
#配置wsgi接口模块文件路径
wsgi-file=django_test/wsgi.py
#配置启动的进程数
processes=4
#配置每个进程的线程数
threads=2
#配置启动管理主进程
master=True
#配置存放主进程的进程号文件
pidfile=uwsgi.pid
#配置dump日志记录
daemonize=uwsgi.log

3.启动，停止，重启，查看

#启动，停止，重启，查看
uwsgi --ini uwsgi.ini #启动
lsof -i :8001    #按照端口号查询
ps aux | grep uwsgi　　　#按照程序名查询
kill -9 13844       #杀死进程
uwsgi --stop uwsgi.pid      #通过uwsg停止uwsgi
uwsgi --reload uwsgi.pid  #重启

4.nginx转发

- 创建文件夹
mkdir -p nginx/conf nginx/html nginx/logs

- 在conf目录下新建nginx.conf

worker_processes  1;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;
    server {
        listen       80;
        server_name  localhost;
        location / {
          # 这里转发方式有两种,http与uwsgi
          #uwsgi_pass 101.133.225.166:8080;
          proxy_pass http://101.133.225.166:8080;
        }  
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

docker run --name nginx -id -p 80:80 -v /home/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /home/nginx/html:/etc/nginx/html -v /home/nginx/logs:/var/log/nginx nginx

# 在 python的docker中用uwsgi跑起项目来即可

外部访问：http://101.133.225.166/

完整步骤

# 第一种方式：基于python基础镜像来做
cd /home
mkdir myproject
cd myproject

docker run -di --name=myproject -p 8080:8080 -v /home/myproject:/home python:3.6
      
#mac/linux    window：xshell拖进去
scp django_test.zip root@101.133.225.166:/home/myproject
# 解压：uzip （安装）yum install -y unzip zip

# 进入容器I 
docker exec -it myproject /bin/bash
# 切到项目路径下：安装依赖
pip install -r requirement.txt
# pip list
apt-get update
apt-get vim
# setting.py 改成下面
ALLOWED_HOSTS = ['*']
# 运行项目(wsgiref)
python manage.py runserver 0.0.0.0:8080
# 换uwsgi跑
pip install uwsgi
# 在项目根路径下创建一个uwsgi.ini 文件，写入

[uwsgi]
#配置和nginx连接的socket连接
socket=0.0.0.0:8080
#也可以使用http
#http=0.0.0.0:8080
#配置项目路径，项目的所在目录
chdir=/home/django_test
#配置wsgi接口模块文件路径
wsgi-file=django_test/wsgi.py
#配置启动的进程数
processes=4
#配置每个进程的线程数
threads=2
#配置启动管理主进程
master=True
#配置存放主进程的进程号文件
pidfile=uwsgi.pid
#配置dump日志记录
daemonize=uwsgi.log


#启动，停止，重启，查看
uwsgi --ini uwsgi.ini #启动
lsof -i :8001    #按照端口号查询
ps aux | grep uwsgi　　　#按照程序名查询
kill -9 13844       #杀死进程
uwsgi --stop uwsgi.pid      #通过uwsg停止uwsgi
uwsgi --reload uwsgi.pid  #重启

# nginx转发

mkdir -p nginx/conf nginx/html nginx/logs

在conf目录下新建nginx.conf

worker_processes  1;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;
    server {
        listen       80;
        server_name  localhost;
        location / {
          #uwsgi_pass 101.133.225.166:8080;
          proxy_pass http://101.133.225.166:8080;
        }  
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

docker run --name nginx -id -p 80:80 -v /home/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /home/nginx/html:/etc/nginx/html -v /home/nginx/logs:/var/log/nginx nginx

# 在 python的docker中用uwsgi跑起项目来即可

外部访问：http://101.133.225.166/

1.2 基于dockerfile

# 第二种方式：dockerfile

# 写一个dockerfile即可

FROM python:3.6
MAINTAINER lqz
WORKDIR /home
RUN pip install django==1.11.9
RUN pip install uwsgi
EXPOSE 8080
CMD ["uwsgi","--ini","/home/django_test/uwsgi.ini"]  # 这句命令，是后台执行的，不会夯住，容器里面就停了

# dockerfile路径下要有一个django_test.tar

#构建镜像
docker build -t='django_1.11.9' .

# 运行容器
docker run -di --name=mydjango -p 8080:8080 -v /home/myproject:/home django_1.11.9


# 以后只需要从git上拉下最新代码，重启，完事（最新代码）

2. mysql主从搭建

原理

mysql主从配置的流程大体如图：

1）master会将变动记录到二进制日志里面；

2）master有一个I/O线程将二进制日志发送到slave;

3. slave有一个I/O线程把master发送的二进制写入到relay日志里面；

4）slave有一个SQL线程，按照relay日志处理slave的数据；

# 为什么要搭建mysql主从？提高并发量（两台机器）
主mysql  从mysql，当主mysql数据发送变化，从mysql也跟着变化

10请求，3个写的，7个读请求
读写分离：写往主库中写  ，读从从库中读

mysql版本必须一致,两个库的server-id 不能一致

docker 配置文件

# 拉取mysql5.7镜像
docker pull mysql:5.7

主库

1 创建文件夹

mkdir /home/mysql
mkdir /home/mysql/conf.d
mkdir /home/mysql/data/

2 配置文件

# 创建my.cnf文件
	touch /home/mysql/my.cnf

3 文件添加内容

vim my.cnf

[mysqld]
user=mysql
character-set-server=utf8
default_authentication_plugin=mysql_native_password
secure_file_priv=/var/lib/mysql
expire_logs_days=7
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
max_connections=1000

##主库----start--- 同一局域网内注意要唯一
server-id=100  
## 开启二进制日志功能，可以随便取（关键）
log-bin=mysql-bin
##主库----end--- 


[client]
default-character-set=utf8

[mysql]
default-character-set=utf8

从库

mkdir /home/mysql2
mkdir /home/mysql2/conf.d
mkdir /home/mysql2/data/
touch /home/mysql2/my.cnf

my.cnf文件中添加

vim my.cnf

[mysqld]
user=mysql
character-set-server=utf8
default_authentication_plugin=mysql_native_password
secure_file_priv=/var/lib/mysql
expire_logs_days=7
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
max_connections=1000

##从库----start--- 
## 设置server_id,注意要唯一
server-id=101  
## 开启二进制日志功能，以备Slave作为其它Slave的Master时使用
log-bin=mysql-slave-bin   
## relay_log配置中继日志
relay_log=edu-mysql-relay-bin 
##从库----end--- 

[client]
default-character-set=utf8

[mysql]
default-character-set=utf8

启动容器

#启动主库容器（挂载外部目录，端口映射成33307，密码设置为123456）
docker run  -di -v /home/mysql/data/:/var/lib/mysql -v /home/mysql/conf.d:/etc/mysql/conf.d -v /home/mysql/my.cnf:/etc/mysql/my.cnf -p 33307:3306 --name mysql-master -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

#启动从库容器（挂载外部目录，端口映射成33306，密码设置为123456）
docker run  -di -v /home/mysql2/data/:/var/lib/mysql -v /home/mysql2/conf.d:/etc/mysql/conf.d -v /home/mysql2/my.cnf:/etc/mysql/my.cnf -p 33306:3306 --name mysql-slave -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

远程连接主库从库

连接主库

# mysql -h 自己的IP -P 33307 -u root -p123456
mysql -h 172.16.209.100 -P 33307 -u root -p123456
#在主库创建用户并授权
##创建test用户
create user 'test'@'%' identified by '123';
##授权用户
grant all privileges on *.* to 'test'@'%' ;
###刷新权限
flush privileges;
#查看主服务器状态(显示如下图)
show master status; 

连接从库

mysql -h 172.16.209.100 -P 33306 -u root -p
123456
#配置详解
/*
change master to 
master_host='MySQL主服务器IP地址', 
master_user='之前在MySQL主服务器上面创建的用户名'， 
master_password='之前创建的密码', 
master_log_file='MySQL主服务器状态中的二进制文件名', 
master_log_pos='MySQL主服务器状态中的position值';
*/
#命令如下
change master to master_host='101.133.225.166',master_port=33307,master_user='test',master_password='123',master_log_file='mysql-bin.000003',master_log_pos=0;
#启用从库
start slave;
#查看从库状态（如下图）
show slave statusG;

测试主从同步

#在主库上创建数据库test1
create database test1;
use test1;
#创建表
create table tom (id int not null,name varchar(100)not null ,age tinyint);
#插入数据
insert tom (id,name,age) values(1,'xxx',20),(2,'yyy',7),(3,'zzz',23);

#在从库上查看是否同步成功
#查看数据库
show database;
use test1;
#查看表
show tables;
#查看数据
select * from test1;

可以看到大功告成

3. django实现读写分离

# 同步表
migrate app01 --databse="db1"


# 手动操作（queryset对象）
ret=Book.objects.all().using("db1")




# 自动做（通过配置，程序，读去从库读，写去主库写）
# 写一个router
在项目路径下创建db_router.py
在里面写一个类
class Router1:
		def db_for_read(self, model, **hints):
				return 'db1'

		def db_for_write(self, model, **hints):
				return 'default'
      
#在setting中配置
DATABASE_ROUTERS = ['db_router.Router1',]

# 只要是写的操作，都到default上，只要是读的操作，都到db1上了

nginx：

动态请求和静态请求（css，js，图片）