迁移与备份，Dockerfile，Docker私有仓库，Docker-compose，Mysql主从搭建，django读写分离

1 迁移与备份

# 一个容器内，尽量只有一个软件，不要把mysql，redis，。。。方到一个容器中，而要放到多个容器

# 镜像---》容器---》装了软件（vim，mysql）---》打包成镜像
# 打包后的镜像----》运行成容器（带了软件）

docker commit 容器id centos-vim:v1   # 容器打包成镜像

docker history 镜像的id  # 查看分层历史   镜像分层：上传，下载镜像加速，底层有的文件不需要再下载了

docker  save -o centos-vim.tar 镜像id  # 把镜像备份成压缩包，copy给别人
docker load -i centos-vim.tar  # 把压缩包，load成镜像
docker tag 20fc287cc64f centos-vim:v1

2 Dockerfile

# 镜像如何获得	
	-1 从远程仓库拉
    -2 通过容器做成镜像
    -3 通过dockerfile构建 （文本文件）
    -4 通过备份的压缩包load回来
# Dockerfile是由一系列命令和参数构成的脚本，这些命令应用于基础镜像并最终创建一个新的镜像
    FROM: 指定基础镜像
    RUN： 构建镜像过程中需要执行的命令。可以有多条。RUN mkdir lqz
    CMD：添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改。
    ENTRYPOINT：同CMD，但这个一定会被执行，不会被覆盖修改。
	# cmd和ENTRYPOINT区别？
    MLABELAINTAINER：表明镜像的作者。将被遗弃，被LABEL代替。
    EXPOSE：设置对外暴露的端口。
    ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效
    ADD：将本地文件或目录拷贝到镜像的文件系统中。能解压特定格式文件，能将URL作为要拷贝的文件
    COPY：将本地文件或目录拷贝到镜像的文件系统中。
    VOLUME：添加数据卷
    WORKDIR：设置工作目录
    
    

# Dockerfile
FROM centos:centos7
MAINTAINER lqz
LABEL author=lqz
WORKDIR /lqz
ENV NAME lqz
RUN echo $NAME
RUN yum install -y vim
COPY redis.conf /root/redis.conf
CMD sleep 50
 
    
# 构建镜像
docker build -t='centos7-vim' .

# 项目根路径会有dockerfile文件
FROM python:3.8
MAINTAINER lqz
WORKDIR /soft
COPY ./requestment.txt /soft/requestment.txt
RUN pip install -r requestment.txt -i https://pypi.doubanio.com/simple
#CMD ["uwsgi", "-x", "./luffy.xml"]
CMD ["uwsgi", "./luffy.ini"]
#CMD ["python", "manage_pro.py", "runserver"]


# 如果公司使用docker开发，部署
	-项目根路径有个dockerfile文件----》开发完了传到git----》部署的机器上---》从git拉下源代码---》docker软件已经有了----》docker build -t='django-soft' .----》docker run -di --name=mysoft -p 8080:8080 -v ./luffy_api:soft django-soft
    -又改了代码---》git上去----》git pull 代码拉下来----》docker restart mysoft----》就看到最新的代码了

3 Docker私有仓库

# 之前的镜像，从远程仓库拉去的，公共的，公司里自己做的镜像，不能传到公共远程仓库----》自己公司搭建私有仓库，把镜像传到私有仓库中


# 把自己做的镜像，传到公共仓库
docker tag 5977ea9eb152 liuqingzheng/centos7-vim:v1
docker login
docker push liuqingzheng/centos7-vim:v1
docker pull liuqingzheng/centos7-vim:v1 # 所有人都可拉

自己搭建私有仓库

（1）拉取私有仓库镜像（此步省略）
docker pull registry
（2）启动私有仓库容器
docker run -di --name=registry -p 5000:5000 registry
（3）打开浏览器 输入地址http://10.0.0.205:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空
（4）修改daemon.json
vi /etc/docker/daemon.json
添加以下内容，保存退出。
{"insecure-registries":["10.0.0.205:5000"]} 
此步用于让 docker信任私有仓库地址
（5）重启docker 服务
systemctl restart docker

6）标记此镜像为私有仓库的镜像
docker tag 5977ea9eb152 10.0.0.205:5000/centos7-vim
（7）再次启动私服容器
docker restart registry
（8）上传标记的镜像
docker push 10.0.0.205:5000/centos7-vim

4 Docker-compose

Docker Compose是一个能一次性定义和管理多个Docker容器的工具，python写的
	单机容器编排，通过yaml文件
    
k8s 多机容器编排，谷歌公司开源的


#安装

curl -L https://get.daocloud.io/docker/compose/releases/download/v2.9.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

# docker-compose命令
# 启动管理容器
docker-compose up  # 会自动搜索当前路径下的 docker-compose.yml文件
docker-compose -f 指定文件 up
docker-compose up -d  # 后台执行，一般我们看日志输出，不用这个
docker-compose stop  # 停止，不会删除容器和镜像
docker-compose down # 停止，并删除关联的容器
docker-compose start  # 启动yml文件管理的容器
docker-compose ps    # 正在运行的容器
docker-compose images # docker-compose管理的容器

docker-compose exec yml文件中写的service /bin/bash  # 进入到容器内

# 写yaml文件




# 写flask项目app.py
from flask import Flask
from redis import Redis
import os
import socket
app = Flask(__name__)
# redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
redis = Redis(host='redis', port=6379)
@app.route('/')
def hello():
    redis.incr('hits')
    return '你好! 查看 %s 次， hostname 是 %s./n' % (redis.get('hits'),socket.gethostname())

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)
    
    
# 写Dockerfile文件
FROM python:3.6
COPY . /app
WORKDIR /app
RUN pip install flask redis -i https://pypi.tuna.tsinghua.edu.cn/simple
EXPOSE 5000
CMD [ "python", "app.py" ]


# 写docker-compose的yaml文件  docker-compose.yml
version: "3"
services:
  redis:
    image: redis
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - 8080:5000
    environment:
      REDIS_HOST: redis
# docker-compose up

version: "3"

services:
  nginx:
    image: nginx
    container_name: luffy_nginx
    ports:
      - "80:80"
      - "8000:8000"
    restart: always
    volumes:
      - ./luffycity/dist:/var/www/html
      - ./docker_compose_files/nginx:/etc/nginx/conf.d
    depends_on:
      - django
    networks:
      - web

  django:
    build:
      context: ./luffy_api
      dockerfile: Dockerfile
    container_name: luffy_django
#    command: python manage_pro.py makemigrations && python manage_pro.py migrate && uwsgi ./luffy.ini
    restart: always
    ports:
      - "8080:8080"
    volumes:
      - ./luffy_api:/soft
    environment:
      - TZ=Asia/Shanghai
    depends_on:
      - mysql
      - redis
    networks:
      - web
  redis:
    image: redis:latest
    container_name: luffy_redis
    ports:
      - "6379:6379"
    volumes:
      - ./docker_compose_files/redis/data:/data
      - ./docker_compose_files/redis/redis.conf:/etc/redis/redis.conf
    command: redis-server /etc/redis/redis.conf
    networks:
      - web
  mysql:
    image: mysql:5.7
    container_name: luffy_mysql
    restart: always
    ports:
      - "3306:3306"
    env_file:
      - ./docker_compose_files/mysql.env
    volumes:
      - ./docker_compose_files/mysql/data:/var/lib/mysql
      - ./docker_compose_files/mysql/logs:/var/log/mysql
      - ./docker_compose_files/mysql/conf:/etc/mysql/conf.d
    networks:
      - web

networks:
  web:
    
    
       
 # 服务器：装docker,docker-compose
git clone xxxxxx
docker-compose up

一键部署luffy前后端项目

# 第一步：在自己机器拉取项目，修改前端连接后端地址
export default {
    base_url: "http://10.0.0.205:8000/api/v1/"
}
#第二步：编译前端项目
npm run build
# 第三步：把最新代码提交到git
git push origin master

# 第四步：在要部署的服务器上（提前安装docker，docker-compose）
git clone  项目地址
cd luffy
docker-compose up

# 第五步：导入数据sql文件
# 第六步：在浏览器访问服务器80端口即可

4 Mysql主从搭建

# 什么是主从同步？
	-一个主库，写数据都写到主库，从库只用来读数据，可以一主一从，可以是一主多从
两台机器：主库，从库   （mysql版本必须一致）


# 原理
mysql主从配置的流程大体如图：
1）master会将变动记录到二进制日志(binlog)里面(主库要开启binlog日志)；
2）master有一个I/O线程将二进制日志发送到slave;
3）slave有一个I/O线程把master发送的二进制写入到relay log日志里面；
4）slave有一个SQL线程，按照relay log 日志处理slave的数据；

# 搭建步骤

## 第一步：拉去mysql5.7镜像
## 第二步：创建一些文件夹，用来做目录映射
# 主库用的
mkdir /home/mysql
mkdir /home/mysql/conf.d
mkdir /home/mysql/data
vim /home/mysql/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

server-id=100
log-bin=mysql-bin


#从库用的
mkdir /home/mysql2
mkdir /home/mysql2/conf.d
mkdir /home/mysql2/data/
vim /home/mysql2/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

server-id=101  
log-bin=mysql-slave-bin   
relay_log=edu-mysql-relay-bin 


## 第三步：启动两个docker容器
###主库
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 3306:3306 --name mysql-master -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7

## 从库
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 3307:3306 --name mysql-slave -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7


### 第四步：链接主库
mysql -h 10.0.0.205 -P 3306 -uroot -p
##创建test用户
create user 'test'@'%' identified by '123';
##授权用户
grant all privileges on *.* to 'test'@'%' ;
###刷新权限
flush privileges;
#查看主服务器状态(显示如下图)
show master status; 

### 第五步：链接从库
mysql -h 10.0.0.205 -P 3307 -uroot -p
change master to master_host='10.0.0.205',master_port=3306,master_user='test',master_password='123',master_log_file='mysql-bin.000003',master_log_pos=0;
# 开启从库
start slave;

# 查看从库状态
show slave status/G;

### 第六步：测试
#在主库上创建数据库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;

5 django读写分离

# 第一步：配置文件配置
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    },
    'db1': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite31'),
    }
}

# 第二步：手动读写分离
# 写到主库
# Book.objects.using('default').create(name='西游记')
#从从库中读
# res=Book.objects.using('db1').all()
# print(res)


#第三步： 自动读写分离
	第一步：写一个类
    class AuthRouter(object):
        def db_for_read(self, model, **hints):
            return 'db1'
        def db_for_write(self, model, **hints):
            return 'default'
    第二步：在配置文件中配	置
	DATABASE_ROUTERS = ['django_test.db_router.AuthRouter', ]