目录
一:部署应用映射外部目录(持久化)
# 部署redis，把配置文件和数据目录映射出来 # 1.操作步骤(创建redis依赖文件) -1 mkdir /reids /redis/conf /redis/data -2 vim /redis/conf/redis.conf # 2.配置文件 bind 0.0.0.0 # 允许所有访问 daemonize NO # 不以后台运行 protected-mode no # 严格模式 requirepass 123456 # 设置密码 # 3.创建并运行容器 docker run -p 6378:6379 --name redis_6379 -v /redis/conf/redis.conf:/etc/redis/redis.conf -v /redis/data:/data -di redis redis-server /etc/redis/redis.conf # -v : 挂载映射 # /etc/redis/redis.conf : 以容器内部redis.conf为启动文件 - redis可视化软件连接
# 4.本地window机器上远程连接到了docker里的redis cmd窗口下 redis-cli -h 101.133.225.166 -p 6378 # 6.认证 auth 123456 # 7.写入数据 set name lqz # 8.保存数据 save或者是bgsave
-9 在宿主机的/redis/data路径下就能看到一个文件 -10 不管多少次重启redis容器，数据都还在 -11 原来的redis容器没了，按照第三步再启动一遍，数据都还在
总结
# 1.配置文件没有配置redis持久化，所以当redis宕机或者停止，redis内数据就会丢失， # 2.我们cmd远程连接到redis，并执行bgsave命令，保存redis数据到data路径下中的dump.rdb文件内，所以当我们停止redis，数据依然存在 # 注意: 1.只是注册演示持久化功能，后面博客更新redis，会详细讲解redis配置持久化。 二:迁移与备份(容器保存为镜像)
1.django执行gitee，项目提交到远端
# django执行gitee，项目提交到远端 git init git commit -m "first commit" git remote add origin https://gitee.com/wwwzhang-com/django_test.git git push -u origin "master"
# 宿主机 mkdir /opt/lqz [root@IronMan ~]# cd /opt/lqz/ [root@IronMan lqz]# git clone https://gitee.com/wwwzhang-com/django_test.git [root@IronMan lqz]# cd django_test/ 2.其他操作
# 删除所有容器（） docker rm `docker ps -a -q` # 删除所有镜像 docker rmi `docker images -q` # 通过自己构建的image镜像启动容器 docker run -id --name=mydjango -p 8088:8088 mydjango python /project/django_test/manage.py runserver 0.0.0.0:8088 # -p : 指定端口映射 # -v : 指定挂载映射 # manage.py : 指定容器内启动文件 # 查看容器运行日志 docker logs 容器id 3.操作步骤
# 操作步骤 1 启动一个python容器 docker run -di --name=mydjango python:3.6 2 进入python容器装软件 docker exec -it mydjango /bin/bash mkdir /project pip install django==2.0.7 exit 3 (宿主)把项目拷贝到容器内部 docker cp /opt/lqz/django_test lqz:/project 4 把容器做成镜像 docker commit lqz mydjango 5 基于自己做的镜像运行容器 docker run -id --name=mydjango -p 8088:8088 mydjango python /project/django_test/manage.py runserver 0.0.0.0:8088 4.容器保存为镜像
docker commit 容器名字 镜像名字 docker commit 19b mydjango pip install django==1.11.11 -i https://pypi.douban.com/simple/
5.把镜像打包成压缩包
docker save -o mydjango.tar mydjango
6.把压缩包回复为镜像
docker load -i mydjango.tar
7.容器内查询全部安装软件
pip list # 查询安装
8.总体代码（迁移与备份(容器保存为镜像)）
# django执行gitee，项目提交到远端 git init git commit -m "first commit" git remote add origin https://gitee.com/wwwzhang-com/django_test.git git push -u origin "master"
# 只是在容器上执行某个命令，并不是进入容器(可以打开bash窗口) docker exec -it python容器id /bin/bash pip install django==2.0.7 https://pypi.doubanio.com/simple/ # 宿主机 mkdir /opt/lqz [root@IronMan ~]# cd /opt/lqz/ [root@IronMan lqz]# git clone https://gitee.com/wwwzhang-com/django_test.git [root@IronMan lqz]# cd django_test/ # 容器 pip list # 查询安装
# 宿主机 1.把容器做成镜像 docker commit 容器名字 镜像名字 docker commit pythonID号 mydjango 2.查询镜像(多了个mydjango) docker images
3. 把镜像打包成压缩包 cd /opt/lqz/ ls # 将镜像打包成压缩包 docker save -o mydjango.tar mydjango 4.把压缩包恢复为镜像 ls -hl # 查询镜像 docker images # 删除镜像 docker rmi mydjango # 查询镜像 docker images
# 把压缩包恢复为镜像 docker load -i mydjango.tar # 查询镜像 docker images
# 重启docker systemctl restart docker # 查询运行容器 docker ps # 删除所有容器（） docker rm `docker ps -a -q` # 删除所有镜像 docker rmi `docker images -q` # 通过自己构建的image启动容器 docker run -id --name=mydjango -p 8088:8088 -v /opt/lqz/django_test:/home/ mydjango python /home/django_test/manage.py runserver 0.0.0.0:8088 # -p : 指定端口映射 # -v : 指定挂载映射 # manage.py : 指定容器内启动文件 # 启动失败情况 # # 查询容器运行的日志 docker logs 容器id docker images docker rmi mydjango # 启动python3容器 docker run -di --name=python3 python:3.6 # 容器 # 进入python3容器 docker exec -it 19b /bin/bash pip install django==2.0.7 https://pypi.doubanio.com/simple/ mkdir project exit # 宿主机 ls lqz/ 目录下 # 将本地的dajngo_Test项目copy到容器project文件夹内 docker cp django_test/ 19b:/project/ # 容器 docker exec -it 19b /bin/bash cd project ls
# django_test exit # 宿主机 lqz/ rm -f mydjango.tar 1.把容器做成镜像 docker commit 容器名字 镜像名字 docker commit pythonID号 mydjango docker images
django_test/目录下 docker rm mydjango # 通过自己构建的image启动容器 docker run -id --name=mydjango -p 8088:8088 -v /opt/lqz/django_test:/home/ mydjango python /home/django_test/manage.py runserver 0.0.0.0:8088 三:Dockerfile和指令讲解
1.简介Dockerfile
# 1.简介Dockerfile： 1.Dockerfile其实就是根据特定的语法格式撰写出来的一个普通的文本文件 2.利用docker build命令依次执行在Dockerfile中定义的一系列命令，最终生成一个新的镜像（定制镜像） # 2.其实他就是一个文件，里面编写了一堆指令，直接通过这个文件可以生成镜像 2.Dockerfile基础指令
| 命令 | 作用 |
|---|---|
| FROM image_name:tag | 定义了使用哪个基础镜像启动构建流程 |
| MAINTAINER user_name | 声明镜像的创建者 |
| ENV key value | 设置环境变量 (可以写多条) |
| RUN command | 是Dockerfile的核心部分(可以写多条) |
| ADD source_dir/file dest_dir/file | 将宿主机的文件复制到容器内，如果是一个压缩文件，将会在复制后自动解压 |
| COPY source_dir/file dest_dir/file | 和ADD相似，但是如果有压缩文件并不能解压 |
| WORKDIR path_dir | 设置工作目录 |
3.解析:
# FROM image_name:tag - 基于那个基础镜像构建的，比如django项目是基于python3.8构建的这里就填写 - FROM python:3.8 # MAINTAINER user_name - 没有什么作用，只是声明这个镜像是谁构建的 # ENV key value - 设置环境变量：可以配置redis/mysql的密码，添加到环境变量中 # RUN command - 这里写的都是linux的命令： - 比如安装一个django则需要编写，RUN pip install django==2.2.2 # ADD source_dir/file dest_dir/file - ADD 宿主机路径 容器路径 - 将宿主机的文件，复制到容器内，如果是一个压缩文件，他会自动解压 # COPY source_dir/file dest_dir/file - 和上述ADD指令一样，但是如果是压缩文件它不会自动解压 # WORKDIR path_dir - 设置工作目录，进入容器后在那个路径下。 4.其他一些指令：
FROM: 指定基础镜像 RUN： 构建镜像过程中需要执行的命令。可以有多条。docker build CMD： 添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改。 ENTRYPOINT： 同CMD，但这个一定会被执行，不会被覆盖修改。 ：为镜像添加对应的数据。 MLABELAINTAINER：表明镜像的作者。将被遗弃，被LABEL代替。 EXPOSE： 设置对外暴露的端口。 ENV： 设置执行命令时的环境变量，并且在构建完成后，仍然生效 ARG： 设置只在构建过程中使用的环境变量，构建完成后，将消失 ADD： 将本地文件或目录拷贝到镜像的文件系统中。能解压特定格式文件，能将URL作为要拷贝的文件 COPY： 将本地文件或目录拷贝到镜像的文件系统中。 VOLUME： 添加数据卷 USER： 指定以哪个用户的名义执行RUN, CMD 和ENTRYPOINT等命令 WORKDIR：设置工作目录 ONBUILD：如果制作的镜像被另一个Dockerfile使用，将在那里被执行Docekrfile命令 STOPSIGNAL： 设置容器退出时发出的关闭信号。 HEALTHCHECK： 设置容器状态检查。 SHELL： 更改执行shell命令的程序。Linux的默认shell是[“/bin/sh”, “-c”]，Windows的是[“cmd”, “/S”, “/C”]。 # 1.写一个Dockerfile（文件名字必须交Dockerfile） vim dockerfile # 写入一下内容 FROM python:3.8 # 基于这个镜像 MAINTAINER bron # 创建者名字：bron EXPOSE 8080 # 开放的端口为 8080 ADD ./requirement.txt /home/ # 将宿主机的requirement文件添加到容器/home路径下 RUN pip install -r /home/requirement.txt -i https://pypi.douban.com/simple/ # 下载依赖文件 RUN pip install uwsgi -i https://pypi.douban.com/simple/ # 下载uwsgi服务 VOLUME ["/home"] WORKDIR /home/django_test # 工作目录 # 启动文件manage.py CMD ["python", "/home/django_test/manage.py", "runserver","0.0.0.0:8080"] # 运行这个容器执行的命令 # CMD ["uwsgi", "--ini", "/home/django_test/uwsgi.ini"] # vim requirement.txt django==2.0.7 pymysql # 2.通过Dockerfile构建出镜像 docker build -t='django_2.2.2' . # 参数: -t ：指定镜像的名字 . ：表示根据当前路径下的Dockerfile来构建镜像 # 3.查看镜像 docker images
pycharm内创建(文件)
# dockerfile FROM python:3.8 # 基于这个镜像 MAINTAINER bron # 创建者名字：bron EXPOSE 8080 # 开放的端口为 8080 ADD ./requirement.txt /home/ # 将宿主机的requirement文件添加到容器/home路径下 RUN pip install -r /home/requirement.txt -i https://pypi.douban.com/simple/ # 下载依赖文件 RUN pip install uwsgi -i https://pypi.douban.com/simple/ # 下载uwsgi服务 VOLUME ["/home"] WORKDIR /home/django_test # 工作目录 # 启动文件manage.py CMD ["python", "/home/django_test/manage.py", "runserver","0.0.0.0:8080"] # 运行这个容器执行的命令 # requirement.txt django==2.0.7 pymysql # settings.py配置 ALLOWED_HOSTS = ['*'] # 提交到git uwsgi.ini配置
[uwsgi] # ; 注释 ;socket=0.0.0.0:8080 http=0.0.0.0:8080 chdir=/home/django_test/ wsgi-file=django_test/wsgi.py # 启动路径 processes=4 # 进程 threads=2 # 线程 master=True pidfile=uwsgi.pid # 启动后生成文件(id号) daemonize=uwsgi.log # 日志 # 导出依赖 # pip freeze # 提交至远端 1.git init 2.git add . 3.git commit -m "first commit" 4.git remote add origin https://gitee.com/wwwzhang-com/aaaa.git 5.git push -u origin "master" # 远端拉取 git clone # 构建docker镜像 # 容器内装了项目的所以依赖 docker build -t='django_2.2.2' . docker images # 如果修改了代码，只需要再次执行远端拉取最新的项目 # 1.从远端拉取 git pull origin master # 2.重启容器 docker restart 容器号 # 这样就是最新的项目了 # 4.启动容器 docker run -di --name=mydjango2 -v /home/tryproject/:/home -p 8081:8080 django_2.2.2 # 解析： - -v ：做了目录映射，将/home/tryproject/路径下的整个项目映射到容器中的/home路径下 - -p ：做了端口映射，访问宿主机的8080则访问到该容器的8080端口 四:通过Dockerfile部署django项目负载均衡
# 1.写一个Dockerfile（文件名字必须交Dockerfile） vim dockerfile # 写入一下内容 FROM python:3.8 # 基于这个镜像 MAINTAINER bron # 创建者名字：bron EXPOSE 8080 # 开放的端口为 8080 ADD ./requirement.txt /home/ # 将宿主机的requirement文件添加到容器/home路径下 RUN pip install -r /home/requirement.txt -i https://pypi.douban.com/simple/ # 下载依赖文件 RUN pip install uwsgi -i https://pypi.douban.com/simple/ # 下载uwsgi服务 VOLUME ["/home"] WORKDIR /home/django_test # 工作目录 # 启动文件manage.py CMD ["python", "/home/django_test/manage.py", "runserver","0.0.0.0:8080"] # 运行这个容器执行的命令 # CMD ["uwsgi", "--ini", "/home/django_test/uwsgi.ini"] requirement.txt
django=2.0.7 pymysql pycharm内创建(文件)
# dockerfile # requirement.txt django==2.0.7 pymysql # settings.py配置 ALLOWED_HOSTS = ['*'] # 提交到git uwsgi.ini配置
[uwsgi] ;socket=0.0.0.0:8080 http=0.0.0.0:8080 chdir=/home/django_test/ wsgi-file=django_test/wsgi.py processes=4 threads=2 master=True pidfile=uwsgi.pid daemonize=uwsgi.log # 2.通过Dockerfile构建出镜像 docker build -t='django_2.2.2' . # 参数: -t ：指定镜像的名字 . ：表示根据当前路径下的Dockerfile来构建镜像 # 3.查看镜像 docker images
# 4.启动容器 docker run -di --name=mydjango2 -v /home/tryproject/:/home -p 8081:8080 django_2.2.2 # 解析： - -v ：做了目录映射，将/home/tryproject/路径下的整个项目映射到容器中的/home路径下 - -p ：做了端口映射，访问宿主机的8080则访问到该容器的8080端口 # 在外部访问即可 1.如果修改了代码，只需要在使用 # 1.从远端拉取 git pull origin master # 2.重启容器 docker restart 容器号 这样就是最新的项目了
# 利用nginx实现负载均衡 1.创建多个容器，启动该项目，做端口映射 - docker run -di --name=mydjango3 -v /home/tryproject/:/home -p 8083:8080 django_2.2.2 - docker run -di --name=mydjango4 -v /home/tryproject/:/home -p 8084:8080 django_2.2.2
# 配置nginx转发 # 1.创建文件夹 mkdir -p /home/tryproject/nginx/conf /home/tryproject/nginx/html /home/tryproject/nginx/logs # 2.配置nginx配置： vim /home/tryproject/nginx/conf/nginx.conf # 在配置文件中写入： worker_processes 1; # 一个进程 events { worker_connections 1024; # 最大的接收数 } http { include mime.types; default_type application/octet-stream; sendfile on; keepalive_timeout 65; upstream node { # 需要监听的端口 server 139.224.1.124:8081; server 139.224.1.124:8083; server 139.224.1.124:8084; } server { listen 80; server_name localhost; location / { #proxy_pass http://101.133.225.166:8080; # 监听单个 #负载均衡配置 proxy_pass http://node; } } } # docker中运行nginx docker run --name nginx -id -p 8889:80 -v /home/tryproject/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /home/tryproject/nginx/html:/etc/nginx/html -v /home/tryproject/nginx/logs:/var/log/nginx nginx # 解析： 启动nginx容器 - -p 8888:80 :实现端口映射，访问8888端口就访问到了80端口，nginx监听的为80端口，我们又在nginx配置文件中配置了请求转发，所以从8888转发到80再转发到nginx转发的那三个端口。 - -v ：将配置映射到容器中
# 重启nginx # 此时就是启动了负载均衡 - 如果其中有一个端口挂掉了也完全不影响 - 如果8081服务挂了，那么就转发的是8083或者8084端口 五:自己制作的镜像上传到docker Hub上
# 第一步：登录docker hub - docker login 使用用户名和密码登录
# 给你要上传的镜像(image)打上标签 - docker tag 镜像号 DockerHub的用户名/上传的镜像名字:版本 # 例： - docker tag a10f jasonborn01/myredis:v1
# 上传到docker hub:只上传没有的那部分 - docker push 标签名字 - docker push jasonborn01/myredis:v1 # 从docker hub 拉取镜像：只拉取没有的那部分 - docker pull jasonborn01/myredis:v1 六:私有仓库搭建
# 我们可以把镜像上传到docker hub上，但是这个镜像是公开的，所有人都可以来取使用，但是如果是公司自己的项目，肯定不可能放到docker hub仓库中，所以需要我们搭建私有仓库。 # 实现： 1 拉取私有仓库一个镜像 docker pull registry 2 启动容器 docker run -di --name=registry -p 5000:5000 registry 3 打开浏览器 输入地址http://47.102.133.190:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空 4 配置(修改daemon.json) vi /etc/docker/daemon.json 添加以下内容，保存退出(仓库位置)。 {"insecure-registries":["47.102.133.190:5000"]} 此步用于让 docker信任私有仓库地址 5 重启docker 服务 systemctl restart docker 6 重启容器 docker start registry 7 测试(将镜像打标签传到私有仓库) docker tag fa5269854a5e 47.102.133.190:5000/helloworld:v1 8 上传到私有仓库 # 重启registry docker start registry docker push 47.102.133.190:5000/helloworld:v1 # 因为指定了路径所以他就会上传到私有仓库 # 删除镜像 docker rm 版本id:v1版本
9 从私有仓库拉取镜像 docker pull 47.102.133.190:5000/helloworld:v1
七:docker-compose的使用
# 1.docker-compose简介: 1.docker-compose是一个单机情况下容器编排的工具, 2.通过yml文件定义多个容器 3.默认名字docker-compose.yml 4 三个概念，Service容器，Networks网络，Volumes数据表 # 2.docker-compose作用： 1.如果现在我们有很多的容器需要启动/停止，那么就需要我们一个个的启/停，此时就需要docker-compose来帮助我们对容器的编排。 # 3.解析： - Compose中定义和启动的每一个容器都相当于一个服务(service) - Compose中能定义和启动多个服务，且它们之间通常具有协同关系 docker-compose安装
# 因为是一个工具所以我们要下载使用： - Docker for Mac与Docker for Windows自带docker-compose # Linux下需要单独安装： - 第一步： sudo curl -L https://github.com/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose # 访问github可能网络原因下载失败，可以(使用国内镜像下载) curl -L https://get.daocloud.io/docker/compose/releases/download/v2.5.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose # 注意(执行完后就会生成docker-compose文件)路径: /usr/local/bin/docker-compose # 第二步设置可执行权限： - chmod +x /usr/local/bin/docker-compose # 验证安装成功： - docker-compose -v
八:docker-compose（ 部署多应用）
docker-compose部署flask-redis
Dockerfile生成镜像
cd opt/lqz/docker_compose_test/ vim Dockerfile # 错 FROM python:3.6 # 基于python:3.8镜像生成镜像 COPY . /app # 将当前目录所有文件copy到镜像中的/app目录下 WORKDIR /app # 设置工作目录 RUN pip install flask redis # 构建镜像过程中需要执行的命令：安装redis和flask EXPOSE 5000 # 开放的端口 CMD [ "python", "app.py" ] # 启动执行的命令 # 对 FROM python:3.6 COPY . /app WORKDIR /app RUN pip install flask redis EXPOSE 5000 CMD [ "python", "app.py" ] docker-compose.yml
vim docker-compose.yml # 错 version: "3" # 固定写法 services: # 固定格式 redis: # 启动redis容器 image: redis # 通过已有redis镜像启动，如果没有则动docker hub拉下来启动 web: # 启动web容器 build: # build 相当于我们使用：docker build -t='django_2.2.2' . build参数使用Dockerfile生成镜像 context: . # 在当前目录下 dockerfile: Dockerfile # 当前目录下的Dockerfile文件 ports: # 映射的端口：相当于 -p 参数 - 8080:5000 # 8080映射5000端口 environment: # 环境变量：相当于 -e 参数 REDIS_HOST: redis # 对 version: "3" services: redis: image: redis web: build: context: . dockerfile: Dockerfile ports: - 8080:5000 environment: REDIS_HOST: redis app.py：项目
vim 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) @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) # 对 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) @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) 启动
docker-compose up
# 此时通过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 # 进入到容器内 十:docker-compose水平扩展
# 使用docker-compose在单机情况实现负载均衡 # 目的： - 把flask_redis项目扩展成多个 # 实现： - 需要在docker-compose.yml文件下加一个负载均衡器HAProxy docker-compose.yml
cd /opt/lqz/docker_compose_test/ vim docker-compose.yml # 1.增加负载均衡器， # 2.可以起多个web，负载均衡器做转发 # 错 version: "3" services: redis: image: redis web: build: context: . dockerfile: Dockerfile environment: REDIS_HOST: redis lb: # 添加负载均衡器haproxy image: dockercloud/haproxy # 通过haproxy镜像，启动容器 links: - web # 管理的容器为web ports: - 8080:80 # 端口转发:8055转发到80端口 volumes: - /var/run/docker.sock:/var/run/docker.sock # 固定路径 # 对 version: "3" services: redis: image: redis web: build: context: . dockerfile: Dockerfile environment: REDIS_HOST: redis lb: image: dockercloud/haproxy links: - web ports: - 8080:5000 volumes: - /var/run/docker.sock:/var/run/docker.sock app.py
# 此时就需要将端口改为80端口 app.run(host="0.0.0.0", port=80, debug=True) 启动
# 参数： --scale 容器名=数量 -d # 例： # 把web扩展为3个从浏览器查看 docker-compose up --scale web=3 -d # 减掉为1个 docker-compose up --scale web=1 -d
实现负载均衡将并发负载给不同的服务器
十一:环境变量相关
# 在我们使用 -e 参数添加环境变量参数的作用： - 例子：docker run -id --name=mypython -e password=123123 python:3.8 - 进入容器：docker exec -it mypython /bin/bash - 查看环境变量：env - 此时我们就可以通过os模块获取到环境变量的值； os.environ.get('password') - 这样我们完全可以把密码等重要信息通过环境变量来获取，避免明文传输提高安全性能。
十二:容器之间通信( 多个容器直接通信方式)
# 方式一：通过宿主机实现容器之间的通信 1 端口映射到宿主机，直接访问宿主机 # 方式二:通过ip地址访问 # 方式二：通过 --link参数 (单项通信) 1 run的时候指定 --link 容器 通过 --link参数 (单项通信)
# 操作步骤: # 1.创建容器1 docker run -di --name=centos1 centos:centos7 # 2.创建容器2 docker run -di --name=centos2 --link centos1 centos:centos7 # 3.进入到centos2中 ping centos1 可以ping同
十三:docker-compose一键部署项目
1.前端编译静态资源
# pycharm.前端编译成静态资源 # cd 前端文件路径 1.安装依赖 npm install 2.编译 cnpm run build
# cd 退回路径 # 提交至远端 1.git init 2.git add . 3.git commit -m "first commit" 4.git remote add origin https://gitee.com/wwwzhang-com/aaaa.git 5.git push -u origin "master" # 参数: 1.增加 -git remote add 名字 远程仓库地址 2.查看 -git remote 3.删除 -git remote remove origin 4.提交到远程仓库 -git push origin master
2.安装Docker
一 安装Docker # 虚拟机 # 安装依赖 yum install -y yum-utils device-mapper-persistent-data lvm2 # 设置yum源 yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo # 安装docker yum install -y docker-ce # 设置开机启动 systemctl enable docker # 启动 Docker systemctl start docker # 查看版本 docker version 3.安装Docker-compose
二 安装Docker-compose # 下载 curl -L https://github.com/docker/compose/releases/download/1.26.2/docker-compose-$(uname -s)-$(uname -m) > /usr/bin/docker-compose # 赋予执行权限 chmod +x /usr/bin/docker-compose # 查看版本 docker-compose --version # 从git上拉去最新项目 git clone https://gitee.com/wwwzhang-com/one-click-deployment-docker.git # 在项目路径下执行（启动docker-compose） docker-compose up -d
# 查询运行容器 docker ps
# 导入测试数据 1.数据库连接导入
# 在浏览器访问服务器地址，就可以看到项目
4.修改pycharm内容(再次上传)
三 修改pycharm内容(再次上传) # pycharm操作 1.提交缓存 git add . 2.提交本地 git commit -m '修改' 3.提交到远端 git push origin master 5.虚拟机拉取远端
四 虚拟机拉取远端 # 拉取远端 git pull origin master
# 停止docker-compose docker-compose down # 启动cocker-compose(代码就是最新的) docker-compose up -d 十四:docker-compose部署解析
Dockerfile
1.构建镜像 #依赖镜像名称和ID FROM python:3.8 #指定镜像创建者信息 MAINTAINER lqz #切换工作目录 RUN mkdir /soft WORKDIR /soft # 把当前路径下的requestment.txt copy 到/soft/requestment.txt里面(配置依赖) COPY ./requestment.txt /soft/requestment.txt RUN pip install -r requestment.txt -i https://pypi.doubanio.com/simple #CMD ["uwsgi", "-x", "./luffy.xml"] # 启动镜像执行容器的时候，就会执行uwsgi命令 CMD ["uwsgi", "./luffy.ini"] #CMD ["python", "manage_pro.py", "runserver"] luffy.ini
[uwsgi] chdir = /soft # 指定路径 master = true wsgi-file = luffy_api/wsgi.py # 指定wsgi的路径 http = 0.0.0.0:8080 # 使用的http协议 chmod-socket = 755 processes = 2 pidfile = /soft/luffy_api/uwsgi.pid #设置缓冲 post-buffering = 4096 docker-compose.yml
version: "3" services: nginx: # nginx容器 image: nginx # 构建nginx(依赖于docker官方的镜像) 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: # django容器 build: context: ./luffy_api dockerfile: Dockerfile # 构建django，依赖于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 # 构建redis container_name: luffy_redis # redis名称 ports: - "6379:6379" # 端口映射 volumes: # 映射路径(当前路径映射到容器内) - ./docker_compose_files/redis/data:/data - ./docker_compose_files/redis/redis.conf:/etc/redis/redis.conf # 当redis容器启动，就执行redis-server /etc/redis/redis.conf command: redis-server /etc/redis/redis.conf networks: # 网络 - web mysql: image: mysql:5.7 # 构建mysql容器 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 # mysql - ./docker_compose_files/mysql/logs:/var/log/mysql # mysql日志 - ./docker_compose_files/mysql/conf:/etc/mysql/conf.d # MySQL配置文件 networks: - web networks: web: nginx/nginx.conf
server { listen 80; # 监听80端口 server_name 127.0.0.1; charset utf-8; location / { # 容器内路径 root /var/www/html; index index.html; try_files $uri $uri/ /index.html; # 解决单页面应用刷新404问题 } } server { listen 8000; # 监听8000端口 server_name 127.0.0.1; charset utf-8; location / { # 容器内路径 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $http_host; proxy_redirect off; proxy_pass http://luffy_django:8080; } # 新增的配置静态文件 location /static { alias /home/project/luffy_api/luffy_api/static; } } redis/redis.conf
bind 127.0.0.1 # 绑定本地访问路径 port 6379 # 开放端口 daemonize no pidfile /var/run/redis_6379.pid databases 16 save 900 1 save 300 10 save 60 10000 dbfilename dump.rdb dir ./ mysql/mysql.env
MYSQL_ROOT_PASSWORD=lqz12345 # root用户:密码 MYSQL_DATABASE=luffy # 创建新数据库 MYSQL_USER=luffy # 新库用户名 MYSQL_PASSWORD=Luffy123? # 新库密码 TZ=Asia/Shanghai 
