最新要闻

广告

手机

iphone11大小尺寸是多少？苹果iPhone11和iPhone13的区别是什么？

iphone11大小尺寸是多少？苹果iPhone11和iPhone13的区别是什么？

 警方通报辅警执法直播中被撞飞：犯罪嫌疑人已投案

警方通报辅警执法直播中被撞飞：犯罪嫌疑人已投案

家电

  1. 首页
  2. 移动通信
  3. 内容

Dockerfile指令与Docker-compose容器编排-搭建docker私有仓库

来源：博客园


(资料图片)

目录
  • 一:部署应用映射外部目录(持久化)
    • 总结
  • 二:迁移与备份(容器保存为镜像)
    • 1.django执行gitee，项目提交到远端
    • 2.其他操作
    • 3.操作步骤
    • 4.容器保存为镜像
    • 5.把镜像打包成压缩包
    • 6.把压缩包回复为镜像
    • 7.容器内查询全部安装软件
    • 8.总体代码（迁移与备份(容器保存为镜像)）
  • 三:Dockerfile和指令讲解
    • 1.简介Dockerfile
    • 2.Dockerfile基础指令
    • 3.解析:
    • 4.其他一些指令：
  • null
        • pycharm内创建(文件)
        • uwsgi.ini配置
  • 四:通过Dockerfile部署django项目负载均衡
    • requirement.txt
        • pycharm内创建(文件)
        • uwsgi.ini配置
  • 五:自己制作的镜像上传到docker Hub上
  • 六:私有仓库搭建
  • 七:docker-compose的使用
    • docker-compose安装
  • 八:docker-compose（ 部署多应用）
    • docker-compose部署flask-redis
  • 九:docker-compose命令
  • 十:docker-compose水平扩展
    • docker-compose.yml
    • app.py
    • 启动
          • 实现负载均衡将并发负载给不同的服务器
  • 十一:环境变量相关
  • 十二:容器之间通信( 多个容器直接通信方式)
    • 通过 --link参数 (单项通信)
  • 十三:docker-compose一键部署项目
    • 1.前端编译静态资源
    • 2.安装Docker
    • 3.安装Docker-compose
    • 4.修改pycharm内容(再次上传)
    • 5.虚拟机拉取远端
  • 十四:docker-compose部署解析
    • Dockerfile
    • luffy.ini
    • docker-compose.yml
    • nginx/nginx.conf
    • redis/redis.conf
    • mysql/mysql.env

一:部署应用映射外部目录(持久化)

# 部署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里的rediscmd窗口下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.gitgit 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    exit3 (宿主)把项目拷贝到容器内部    docker cp /opt/lqz/django_test lqz:/project    4 把容器做成镜像    docker commit lqz mydjango5 基于自己做的镜像运行容器    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 mydjangopip 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.gitgit 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号 mydjango2.查询镜像(多了个mydjango)docker images
3. 把镜像打包成压缩包cd /opt/lqz/ls# 将镜像打包成压缩包docker save -o mydjango.tar mydjango4.把压缩包恢复为镜像ls -hl # 查询镜像docker images# 删除镜像docker rmi mydjango# 查询镜像docker images
# 把压缩包恢复为镜像docker load -i mydjango.tar# 查询镜像docker images
# 重启dockersystemctl 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 容器iddocker imagesdocker rmi mydjango# 启动python3容器docker run -di --name=python3 python:3.6# 容器    # 进入python3容器        docker exec -it 19b /bin/bashpip install django==2.0.7 https://pypi.doubanio.com/simple/    mkdir projectexit# 宿主机lslqz/ 目录下# 将本地的dajngo_Test项目copy到容器project文件夹内docker cp django_test/ 19b:/project/    # 容器    docker exec -it 19b /bin/bashcd projectls
# django_testexit# 宿主机lqz/rm -f mydjango.tar1.把容器做成镜像docker commit 容器名字 镜像名字docker commit pythonID号 mydjangodocker 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 buildCMD：添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改。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   # 创建者名字：bronEXPOSE 8080   # 开放的端口为 8080ADD ./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.pyCMD ["python", "/home/django_test/manage.py", "runserver","0.0.0.0:8080"]   # 运行这个容器执行的命令# CMD ["uwsgi", "--ini", "/home/django_test/uwsgi.ini"]
# vim requirement.txtdjango==2.0.7pymysql
# 2.通过Dockerfile构建出镜像docker build -t="django_2.2.2" .  # 参数:-t ：指定镜像的名字. ：表示根据当前路径下的Dockerfile来构建镜像    # 3.查看镜像docker images
pycharm内创建(文件)
# dockerfileFROM python:3.8    # 基于这个镜像MAINTAINER bron   # 创建者名字：bronEXPOSE 8080   # 开放的端口为 8080ADD ./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.pyCMD ["python", "/home/django_test/manage.py", "runserver","0.0.0.0:8080"]   # 运行这个容器执行的命令# requirement.txtdjango==2.0.7pymysql# settings.py配置ALLOWED_HOSTS = ["*"]# 提交到git
uwsgi.ini配置
[uwsgi]# ; 注释;socket=0.0.0.0:8080http=0.0.0.0:8080chdir=/home/django_test/wsgi-file=django_test/wsgi.py  # 启动路径processes=4  # 进程threads=2  # 线程master=Truepidfile=uwsgi.pid  # 启动后生成文件(id号)daemonize=uwsgi.log  # 日志
# 导出依赖# pip freeze# 提交至远端1.git init2.git add .3.git commit -m "first commit"4.git remote add origin https://gitee.com/wwwzhang-com/aaaa.git5.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   # 创建者名字：bronEXPOSE 8080   # 开放的端口为 8080ADD ./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.pyCMD ["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.7pymysql
pycharm内创建(文件)
# dockerfile# requirement.txtdjango==2.0.7pymysql# settings.py配置ALLOWED_HOSTS = ["*"]# 提交到git
uwsgi.ini配置
[uwsgi];socket=0.0.0.0:8080http=0.0.0.0:8080chdir=/home/django_test/wsgi-file=django_test/wsgi.pyprocesses=4threads=2master=Truepidfile=uwsgi.piddaemonize=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{   # 需要监听的端口server139.224.1.124:8081;server139.224.1.124:8083;         server139.224.1.124:8084;}    server {        listen 80;        server_name  localhost;        location / {          #proxy_pass http://101.133.225.166:8080;  # 监听单个          #负载均衡配置          proxy_pass http://node;        }      }}
# docker中运行nginxdocker 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 registry2 启动容器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 上传到私有仓库# 重启registrydocker start registrydocker 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.yml4 三个概念，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和flaskEXPOSE 5000# 开放的端口CMD [ "python", "app.py" ]    # 启动执行的命令# 对FROM python:3.6COPY . /appWORKDIR /appRUN pip install flask redisEXPOSE 5000CMD [ "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 Flaskfrom redis import Redisimport osimport socketapp = 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 Flaskfrom redis import Redisimport osimport socketapp = 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

![ok你的的啊 啊](C:\Users\86130\Pictures\diyy 11\ok你的的啊 啊.gif)

# 此时通过docker-compose就一步操作，就直接可将项目运行起来，无需输入太多的命令。实现对单机情况下容器编排。

九:docker-compose命令

# 启动管理容器docker-compose up  # 会自动搜索当前路径下的 docker-compose.yml文件docker-compose -f 指定文件 updocker-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
实现负载均衡将并发负载给不同的服务器

![跨域处理](C:\Users\86130\Pictures\diyy 11\跨域处理.gif)

十一:环境变量相关

# 在我们使用 -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.创建容器1docker run -di --name=centos1 centos:centos7# 2.创建容器2docker run -di --name=centos2 --link centos1 centos:centos7    # 3.进入到centos2中 ping centos1 可以ping同

十三:docker-compose一键部署项目

1.前端编译静态资源

# pycharm.前端编译成静态资源# cd 前端文件路径1.安装依赖npm install2.编译cnpm run build
# cd 退回路径# 提交至远端1.git init2.git add .3.git commit -m "first commit"4.git remote add origin https://gitee.com/wwwzhang-com/aaaa.git5.git push -u origin "master"# 参数:1.增加-git remote add 名字 远程仓库地址2.查看-git remote3.删除-git remote remove origin4.提交到远程仓库-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# 安装dockeryum install -y docker-ce# 设置开机启动systemctl enable docker# 启动 Dockersystemctl 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.构建镜像
#依赖镜像名称和IDFROM python:3.8#指定镜像创建者信息MAINTAINER lqz#切换工作目录RUN mkdir /softWORKDIR /soft# 把当前路径下的requestment.txt copy 到/soft/requestment.txt里面(配置依赖)COPY ./requestment.txt /soft/requestment.txtRUN 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 = 755processes = 2pidfile = /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:      - webnetworks:  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.piddatabases 16save 900 1save 300 10save 60 10000dbfilename dump.rdbdir ./

mysql/mysql.env

MYSQL_ROOT_PASSWORD=lqz12345  # root用户:密码MYSQL_DATABASE=luffy  # 创建新数据库MYSQL_USER=luffy  # 新库用户名MYSQL_PASSWORD=Luffy123?  # 新库密码TZ=Asia/Shanghai

关键词： 环境变量 负载均衡