一、应用部署

1.MySQL部署

	'在dokcer中部署mysql，以后不需要在宿主机上装mysql'
	1.做端口映射
		docker run -id --name=mysql5.7 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=1234 mysql:5.7
	2.做目录映射
		-如果没有做目录映射，在mysql容器中表数据一旦删除就所有都没有了，一旦做了目录映射，重新创建相同的,数据会在里面还在
		1.docker pull mysql:5.7  拉取镜像
		2.mkdir /mysql  # 创建文件夹数据分离  在根目录下
		  mkdir /mysql/conf.d
		  mkdir /mysql/data/
		'创建好文件 写入配置'
	  	3.vim /mysql/my.cnf  # 如果在宿主机上没有安装vim，就使用vi创建
	  	  '写入数据，就是和本机上面安装的mysql的配置文件差不多参数'
	  	[client]
		default-character-set=utf8
		[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
		4.做目录映射  # 基于镜像运行成容器 端口映射3306 目录映射
		docker run -di -v /mysql/data/:/var/lib/mysql -v /mysql/conf.d:/etc/mysql/conf.d -v /mysql/my.cnf:/etc/mysql/my.cnf -p 3307:3306 --name mysql5.7 -e MYSQL_ROOT_PASSWORD=1234 mysql:5.7
		5.本地链接好容器mysql5.7，创建库、创建表，插入数据
		6.关闭容器，删除容器，这样mysql的容器就没有了，但是数据还在宿主机上放着
			docker stop mysql5.7
			docker rm mysql5.7
		'这个时候删除容器 数据还在 只需要再创建一个新的容器 做好目录映射就可以继续使用了,目录保持一致，密码保持一致'

2.Redis部署

	
	1.docker pull redis 	# 拉取redis镜像,不写版本默认latest
	2.mkdir /root/data    # 根目录创建data文件夹
	3.vim /root/redis.conf  # 创建并编辑redis配置文件
		bind 0.0.0.0
		daemonize NO
		protected-mode yes
		requirepass 1234
	4.运行创建
		-启动容器时，运行的命令是什么 redis-server /etc/redis/redis.conf
		-在容器运行时，可以自己定制运行命名 举例：docker run -id centos:centos7 ls
		docker run -id  -p 6379:6379 --name redis -v /root/redis.conf:/etc/redis/redis.conf -v /root/data:/data redis  redis-server /etc/redis/redis.conf
	5.运行redis容器，并写入数据，用本地能链接redis的软件链接一下查看,或者直接cmd链接
		docker exec -it redis /bin/bash
		'容器redis链接'
		redis cli  # 链接
		auth xxxx # 密码
		'cmd窗口链接查看'
		redis-cli -h ip地址 -p 端口号
		auth 密码
		'resp链接：填入链接名称(随意填)、地址、密码即可'

3.Nginx部署

1.docker pull nginx 	# 拉取nginx镜像
'没做映射操作'
2.docker run -id --name=nginx -p 80:80 nginx  # run起容器
3.从win机器浏览器可以访问：xx.xxx.xx:80
4.进入容器内部，修改index    /usr/share/nginx/html
	docker exec -it nginx /bin/bash
5.修改index.html
	vi、vim、yum都没有因为不是Centos系统
	apt-get update
	apt-get install vim
'做映射操作'
6.做目录映射
	# /usr/share/nginx/html
	-docker run -id --name nginx1 -p 8088:80 -v /root/html:/usr/share/nginx/html nginx
	-cd /root/html
	-vi index.html  随便填入html文本 <h1>hello world!</h1>
	-进入到容器内部后到/usr/share/nginx/html目录就可以看到映射过来的index.html文件了
	'以后只需要修改宿主机的/root/html 路径，看到页面就是修改后的'

二、迁移与备份

1.容器做成镜像

	-镜像从哪来的？
		1 docker pull 拉的
	    2 通过容器打包成镜像
	    	-centos镜像运行成容器---》装了vim
	        -把装了vim的容器---》打包成镜像
	        -以后拿到这个镜像--》再运行成容器，都会带vim命令
	        
	    3 Dockerfile构建

	-容器保存为镜像
		-运行一个centos容器
		docker run -id --name centos_vim centos:centos7
		-在容器中装vim
		docker exec -it a6e240 /bin/bash
		yum install vim -y
		
		-把容器做成镜像（centos+vim）  需要退出容器，在宿主机上操作
		docker commit 容器名 镜像名
		docker commit centos_vim centos_vim
		
		-把centos_vim 容器删除
		docker rm centos_vim -f
		-基于新构建的镜像，运行成容器
		docker run -id --name centos_vim centos_vim:latest
		-进入到容器中，查看，软件都在
		docker exec -it c3e633bd1 /bin/bash

2.镜像备份和恢复(打包成压缩包）

	'镜像的备份和恢复'
	-把镜像做成压缩包
		docker save -o 压缩包名	镜像名/镜像id
		docker save -o mynginx.tar nginx  	# 把镜像做成tar文件
	-删除原有镜像
	-把备份的镜像恢复
		docker load -i 压缩包名
		docker load -i mynginx.tar			# 把压缩包load成镜像

三、DockerFile

0.镜像从哪里来？

	1 远程仓库拉取的 docker pull   （hub.docker---》搭建私有仓库）
    2 用容器做成的镜像 docker commit 
    3 把备份的恢复 docker load
    4 使用Dockerfile来构建(这种多)

1.什么是DockerFile

Dockerfile其实就是根据特定的语法格式撰写出来的一个普通的文本文件
利用docker build命令依次执行在Dockerfile中定义的一系列命令，最终生成一个新的镜像（定制镜像）文件名必须叫Dockerfile。

Dockerfile是由一系列命令和参数构成的脚本，这些命令应用于基础镜像并最终创建一个新的镜像。

1. 对于开发人员：可以为开发团队提供一个完全一致的开发环境；
2. 对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像开始工作了；
3. 对于运维人员：在部署时，可以实现应用的无缝移植。

2.DockerFile 构建特征

1.DockerFile必须具备一个FROM命令来进行构建
2.每一个Dockerfile命令都会构建一层镜像（本质上是每一层都会启动一个容器，执行完命令后，将容器进行提交后，产生新的镜像层）
3.通过查看下载下来的镜像，发现历史层信息的层ID是missing，其实是因为原本的层id只存在于构建镜像的宿主机上，一旦转移镜像后，历史层消息中将只保留最新一层的ID

3.DockerFile命令描述

	详细指令介绍：https://zhuanlan.zhihu.com/p/419175543
	
	'常用命令'
	FROM: 指定基础镜像
	RUN： 构建镜像过程中需要执行的命令。可以有多条。docker build
	CMD：添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改
	ENTRYPOINT：同CMD，但这个一定会被执行，不会被覆盖修改。
	：为镜像添加对应的数据。
	MLABELAINTAINER：表明镜像的作者。将被遗弃，被LABEL代替。
	ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效
	ARG：设置只在构建过程中使用的环境变量，构建完成后，将消失
	ADD：将本地文件或目录拷贝到镜像的文件系统中。能解压特定格式文件，能将URL作为要拷贝的文件
	COPY：将本地文件或目录拷贝到镜像的文件系统中。
	WORKDIR：设置工作目录
	
	'''不怎么常用命令'''
	EXPOSE：设置对外暴露的端口。
	VOLUME：添加数据卷
	USER：指定以哪个用户的名义执行RUN, CMD 和ENTRYPOINT等命令
	ONBUILD：如果制作的镜像被另一个Dockerfile使用，将在那里被执行Docekrfile命令
	STOPSIGNAL：设置容器退出时发出的关闭信号。
	HEALTHCHECK：设置容器状态检查。
	SHELL：更改执行shell命令的程序。Linux的默认shell是[“/bin/sh”, “-c”]，Windows的是[“cmd”, “/S”, “/C”]。


	'CMD与ENTRYPOINT'
	1.相同点：
		只能写一条，如果写了多条，那么只有最后一条生效。
		容器启动时才运行，运行时机相同。
	2.不同点：
		ENTRYPOINT不会被运行的command覆盖，而CMD则会被覆盖。
		如果我们在Dockerfile中同时写了ENTRYPOINT和CMD，并且CMD指令不是一个完整的可执行命令，那么CMD指定的内容将会作为ENTRYPOINT的参数
	
	
	'ARG 和 ENV'
		ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效
		ARG：设置只在构建过程中使用的环境变量，构建完成后，将消失

4.构建一个带vim的centos镜像案例

	'构建一个带vim的centos:7镜像,根路径下有/jack/xx.py'

	1.在宿主机上创建一个文件(文件名必须叫Dockerfile)，文件里面书写下面的
		-vim Dockerfile
			'''
			ENV 环境变量
			touch 创建文件
			echo 输出 等同于print
			echo 'xxx' > /xx.py   > 就是放入到指定文件中
			mv 1.txt test.txt  mv移动，也可以是重命名
			copy 复制到指定文件中
			workdir jack 工作目录，创建完毕后进入时会直接进入到这个目录
			'''
			FROM centos:centos7
			MAINTAINER WhiteG
			ENV name jack
			RUN yum install vim -y &&\
			mkdir /jack &&\
			touch /jack/xx.py &&\
			echo 'print(hello world)' > /jack/xx.py
			COPY ./test.txt /jack/test.txt
			WORKDIR /jack
			'''
			注意如果在这里使用了CMD命令，例如CMD ['python' './jack/xx.py']，
			运行容器时会默认加上 /bin/bash -c(可以在docker images 的COMMAND看) 这个是以shell形式，运行时，linux默认会加上的
			'''
			'然后保存退出，也可以查看一下 cat Dockerfile是否修改内容成功'

	2.基于dockerfile构建镜像, '.' 是基于当前路径下的Dockerfile 构建镜像  
		-docker build -t='centos_jack_vim' .

	3.可以查看是否构建成功镜像   docker images
	4.基于这个构建的镜像运行成容器
		# 因为建构的镜像没有写版本，默认就是latest，只要是latest，可写可不写
		- docker run -id --name xx centos_jack_vim:latest
		'上面的CMD命令方式运行，会自动加上/bin/bash -c 所以我们可以修改直接在把镜像运行成容器时添加启动命令即可'
		'docker run -id --name xx centos_jack_vim python /jack/xx.py'
	
	5.进入到容器内
		-docker exec -it xx /bin/bash
	6.验证vim，和文件夹，文件是否存在
		-使用python的方式查看环境变量
			1.python中，导入模块 import os
			2.os.environ.get('name')  # 获取对应环境变量
		-使用shell命令查看环境变量
			echo $name  # 使用echo输出即可

5.DockerFile构建Django项目

	'在公司中，使用Docker开发的工作流程：'
	1.开发完一个Django项目
    2.然后在项目路径下新建Dockerfile，编辑下面内容：
        FROM python:3.8
        MAINTAINER WhiteG
        WORKDIR /soft
        COPY ./requirements.txt /soft/requirements.txt
        RUN pip install -r requirements.txt -i https://pypi.doubanio.com/simple
        CMD ["python","manage.py","runserver","0.0.0.0:8080"]
        
	3.把代码提交到git/或者私有仓库中
		'这里我以git 为例'
		-git init # 初始化
		-然后git仓库创建新的空仓库，然后粘贴对应的命令
		-git add .
		-git commit -m '' # 提交到版本库
		-git push origin master 
		
	4.在部署项目的机器上，clone（克隆）项目
		-在部署项目的机器上安装 yum install git
		-git clone https://gitee.com/xxxx/xxxxx.git
		
	5.构建镜像 ，cd到对应的文件夹中 执行构建命令
		-docker build -t='django_books' .   # 点表示从当前路径的Dockerfile中构建镜像
		
	6.把刚刚构建的镜像运行成容器，并做目录映射、端口映射
		-docker run -id --name=books -v /root/docker_books:/soft -p 8080:8080 django_books:latest
		"""
		如果镜像不是django_books目录下构建的，它是找不到dockerfile文件的
		解决方法：停止容器  删除容器  删除镜像  切到books下新构建新镜像
		"""
	7.这样直接访问宿主机的8080端口就能看到项目的前端页面了
	
	8.后续只需要开发人员继续提交代码到仓库(push)
	
	9.运维人员在部署的机器上拉取仓库代码(pull)，然后重启容器，这样就可以直接看到最新的页面了
		-注意需要再第一次拉取的项目文件夹中拉取，否则无效
		-cd docker_books 
		-git pull origin master
		-docker restart books # 重启容器
	'''
	注意：如果是开发修改了项目依赖,然后修改requirements.txt，就需要重写构建镜像，然后在运行容器的操作了，
	如果是开发修改代码逻辑，为了做版本区分，也是需要做新版本镜像，这样也是需要重构新镜像
	'''

四、docker私有仓库

docker官方提供的远程仓库，可以把自己定义的镜像传上去，就是自己的私有镜像（可公开）。公司做的镜像一般不放在远程仓库，会放在公司自己搭建私有仓库（把公司制作的镜像传到私有仓库）

1.镜像传到官方仓库

	第0步：在远端创建仓库
	第一步：给镜像打标签
		docker tag 本地镜像名:标签  你的名字/镜像名字:标签
        例如：docker tag centos:centos7   0jchen/centos7:latest
        
	第二步：登录到远程仓库(官方的hub.docker)
		docker login  # 输入注册的docker官方账号和密码
		
	第三步：将镜像提交docker远程仓库
	    docker push 0jchen/centos7:latest
	    
	第四步：别人就可以下载了
		docker pull 0jchen/centos7:latest

2.镜像分层

每一个Dockerfile命令都会构建一层镜像（本质上是每一层都会启动一个容器，执行完命令后，将容器进行提交通过查看下载下来的镜像，发现历史层信息的层ID是missing，其实是因为原本的层id只存在于构建镜像的宿主机上，一旦转移镜像后，历史层消息中将只保留最新一层的ID.

	'只要执行一个命令就会多一层，例如：'
		-RUN yum install vim -y
		-RUN yum install git -y
		-这样就会多出好几层，这也是为什么我上面的一个案例里面会把RUN命令都合并的写(&&)，这样能减少镜像分层的层数
		
	'查看镜像分层的命令'
		docker history  镜像名:版本
	'而分层少的的好处：构建快，分发方便，如果本地有某一层了，这一层就不需要下载了'

	'所以以后：Dockerfile写命令，建议多条命令合为一条，这样就只会生成一层，例如：'
		-使用了\就是换行，这样在Dockerfile文件中就可以换行写，不然就只能一行的写，观看效果不好
		RUN python -m pip install --upgrade pip &&\
        python -m pip install --upgrade setuptools &&\
        pip install -r requirements.txt

3.私有仓库创建

企业级的私有仓库Harbor (有图形化界面，跟hub.docker 很像)，harbor部署与使用具体自行搜索即可

docker搭建私有仓库(registry，这个是没有图形化界面)

	'Harbor就是封装了Docker的registry v2，然后做了图形化界面'
	这里就演示搭建一个registry私有仓库

	'搭建步骤：(使用docker搭建docker私有仓库)'
	1.拉取registry镜像
		docker pull registry
		
	2.registry镜像运行成容器
		docker run -di --name=registry -p 5000:5000 registry

	3.这是个web服务端，所以需要从浏览器中访问它
		-打开浏览器 输入地址http://10.0.0.110:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空
	4.修改daemon.json
		vi /etc/docker/daemon.json  # 这个之前创建的时候配置过国内镜像下载
		# 配置私有仓库的地址，就是ip地址+端口号
	    {
	        "insecure-registries":["10.0.0.110:5000"]  
	    } 
    5.重启docker和重启容器，让配置生效
    	systemctl restart docker
    	docker start registry
   	6.把某个镜像tag成私有仓库的镜像
   	 	docker tag 镜像名字/id IP地址:端口/私有仓库镜像名:版本  # 版本可以不填，默认latest
   	 	docker tag django_books 10.0.0.110:5000/django_books
	7.提交到私有仓库
		docker push 10.0.0.110:5000/django_books
	8.其他人，只要配置了私有仓库就可以直接拉取
		docker pull 10.0.0.110:5000/django_books

五、Docker-Compose介绍及下载

1.介绍docker-compose

使用docker部署项目时，会存在一个问题，例如一个Django项目中，把mysql、redis都放在一个容器中，之后不好使用服务，如果每个服务放在一个容器，批量管理多个容器，比较难操作，于是出现了docker-compose

docker-compose是一个能一次性定义和管理多个Docker容器的工具，单机容器编排【定义和管理】。Compose中定义和启动的每一个容器都相当一个服务（service)，Compose中能定义和启动多个服务，且它们之间通常具有协同关系。管理方式：

1. 使用YAML文件来配置我们应用程序的服务。
2. 使用单个命令（docker-compose up），就可以创建并启动配置文件中配置的所有服务。

多容器编排的工具：

	-docker swarm：公司里用的不多
	-k8s是多机容器编排工具，go语言写了k8s

2.下载docker-compose

安装docker-compose （可执行文件，放在了github上，下载下来即可，速度很慢）
https://github.com/docker/compose/releases
'然后找到自己想要的对应版本的docker-compose复制链接即可，例如docker-compose-linux-x86_64 v2.24.6版本'
https://github.com/docker/compose/releases/download/v2.24.6/docker-compose-linux-x86_64

-使用压缩包形式下载
1.在docker上安装yum install wget -y
	wget https://github.com/docker/compose/releases/download/v2.24.6/docker-compose-linux-x86_64
2.本地下载上传到docker上
'因为去github官方下载很慢，所以我这里选择自己在本地下载好，使用yum install lrzsz软件'
	rz 从本地文件中导入进来

-复制目录
'想在任意路径下执行docker-compose都有相应反应，就需要把可执行文件放到环境变量所在的目录下'
cp ./docker-compose /usr/local/bin/docker-compose 
/usr/local/bin/ 这个目录就是在环境变量当中

-给执行的权限
chmod +x /usr/local/bin/docker-compose
'''
+x linux中的执行权限，具体可自行查找资料
ls -al  查看权限
rwx    rwx    rwx
属主   属组   其他
 r：read 读权限 
 w：wirte 写权限
 x：执行权限

chmod +x 表示添加执行权限
chmod +r 表示添加读权限
chmod +w 表示添加写权限

属主   属组  所有人
chmod  777   文件名   777就是最高权限三个rwx全都有

--------------------

rwx   rwx   rwx
000	  000   000  使用二进制来表示每个rwx的三位，二进制只有0、1
(逢二进一[第一位需要到二就第二位为一]，到第二位进第三位也是逢二进一)，所以一个rwx就需要7，因此三个rwx就是777

例如：chmod 555 文件名
当rwx中有为零的则用-表示，如果全为零---表示
r-x  r-x  r-x
101  101  101
这个例子就是表示只有当前文件的所有的读权限和执行权限
'''  

-这样以后在任意位置敲docker-compose都可以


'''
补充：使用epel源 （epel源为“红帽系”的操作系统提供的额外的软件包，适用于RHEL，CentOS）
我们正常下载就去centos系统对应的仓库下载(别的系统就去它对应的系统仓库下载)
但是仓库的软件不够全面，只提供了一些常规的
这就是为什么要使用epel源，epel源，是一个扩展源，这个源仓库软件非常多，像nginx、redis等等都可以直接下载
这个源唯一的缺点就是不能指定下载的镜像版本

具体如何下载及配置自行查找资料，yum install -y epel-release 安装
'''

3.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  # 进入到容器内

六、使用docker-compose部署flask-redis项目

flask项目，使用redis服务---->2个容器

1. 新建flask项目app.py

from flask import Flask
from redis import Redis
import os

app = Flask(__name__)
# redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
# 容器的主机名---》flask容器和redis容器是能ping通的（同一个网段），可以通过ip ping 也可以通过主机名ping
redis = Redis(host='redis', port=6379)

@app.route('/')
def hello(): 
    redis.incr('hits')
    return '你好! 查看 %s 次\n' % (redis.get('hits'))


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)

2. 编写Dockerfile构建flask项目

FROM python:3.9
WORKDIR /app
COPY . /app
RUN pip install flask redis -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
EXPOSE 5000
CMD [ "python", "app.py" ]

# 构建出镜像，一会统一使用 docker-compose构建

3. 编写docker-compose 的yml文件docker-compose.yml

'注意，必须要缩进好'
version: "3"
services:
  redis:
    image: redis
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - 8080:5000
    environment:
      REDIS_HOST: redis

4. docker-compose启动

1.使用docker-compose构建并启动(一键部署：redis，和flask ，每个都在一个容器中)
	docker-compose up
2.ping redis  连接
 # 进入到了web，ping redis
    # 安装ping命令，
    apt-get update
    apt-get install inetutils-ping
    ping redis

3.这样删除后，在使用docker-compose up可以直接一键自动部署好
	docker-compose up
		-构建flask镜像
	    -reids镜像如果不存在，就会拉取
	    -启动flask
	    -启动redis

七、docker-compose一键部署前后端分离项目

前要介绍

1.一台服务器：
	-python3.8 环境 djagno +uwsgi+代码
    -nginx软件
    -mysql 5.7
    -redis 
    
2.每个都做成一个容器
	   -djagno项目容器：python3.8 构建的django，模块，uwsgi，代码
    -nginx容器：目录映射，映射到宿主机，代理vue前端，编译后的静态文件
    -mysql 容器：创建，创用户，密码，luffy库
    -redis 容器，跑起来即可
    

3.项目部署过程
3.1.前端项目
  # 把luffycity/dist 文件夹删除
  # 把\luffy\luffycity\src\assets\js\settings.js后端地址改成上线地址(服务器地址)
  # 来到前端路径下：luffy\luffycity
       cnpm install  安装依赖
  # 编译，在\luffy\luffycity\dist文件夹
       npm run build--》dict文件  # 切到前端luffycity路径下

  # 提交到git上

3.2.线上操作
# 在部署的机器上，git clone 下来
# 进入到项目目录luffy
  docker-compose up  # docker提前把docker-compose装好
# 直接访问公网+后端8000可以访问后台，公网+80就可以访问前台了
# 如果数据没有，可能数据库没起



4.部署路飞项目
-后端写一个Dockerfile,构建镜像
- mysql,redis,nginx 基于官方
-nginx：代理前端，请求转发---》自己的配置文件
-redis：目录映射，数据放到宿主机，配置文件宿主机的
-mysql：创建用户，创建库
 
 -docker-compose up -d
 -数据库导入，部署完成

1.项目目录结构

luffy
	-docker_compose_files  # nginx有自己的配置文件，redis自己的配置，mysql的配置
        nginx # 文件夹，nginx配置---》
        	-default.conf  # 手动配置，需要监听两个端口：80 给前端和8000转发给django
        redis # 文件夹
        	- redis.conf  # nginx监听地址和端口，持久化方案
        mysql.env # 配置文件，mysql的配置---》key vaule形式---》环境变量
        	# 运行mysql容器时， -e参数 ，设置超级用户密码，创建luffy用户和库
            
    -luffy_api  # 原来路飞后端项目
    	-Dockerfile  # 用来构建 项目镜像
        -luffy.ini  # 等同于 luffy.xml   uwsgi的配置文件
        -luffy.sql  # 默认数据
    -luffycity  # 前端项目
    
    -docker-compose.yml  # docker-compose的配置文件

2.配置编译

1 git clone https://gitee.com/liuqingzheng/luffy.git
2  把luffycity/dist 文件夹删除

3 把\luffy\luffycity\src\assets\js\settings.js后端地址改成上线地址(服务器地址)
    export default {
        base_url: "http://10.0.0.111:8000/api/v1/"
    }
4 来到前端路径下：luffy\luffycity
cnpm install  # 安装依赖

5 编译，在\luffy\luffycity\   这样就会生成一个dist文件夹
npm run build

6 提交到git上
git add .
git commit -m 'xx'
git push origin master

7 在部署的机器上，git clone 下来
git clone https://gitee.com/hanioye/docker_luffy.git


8 进入到项目目录
cd docker_luffy/
docker-compose up

9 导入 sql文件


10 访问 服务器地址的80端口，即可

3.luffy_api/Dockerfile—>构建uwsgi+django

#依赖镜像名称和ID
FROM python:3.8
#指定镜像创建者信息
MAINTAINER lqz
#切换工作目录
RUN mkdir /soft
WORKDIR /soft
COPY ./requestment.txt /soft/requestment.txt
RUN pip install -r requestment.txt -i https://pypi.doubanio.com/simple
CMD ["uwsgi", "./luffy.ini"]

4.docker-compose.yml

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:6.0-alpine
    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-compose up