1.通过docker部署django项目

1.创建一个django项目，将django项目提交到gitee

2.进入虚拟机的/opt目录下创建yessir文件夹，进入yessir文件夹，通过git clone将gitee仓库的项目拉下来

cd /opt

mkdir yessir

cd yessir

git clone https://gitee.com/yessir_ye/django_test.git 
    

3.通过python3.6镜像启动一个python的容器，创建/project文件夹，并在里面安装djang1.11.11

docker run -di --name python3 python:3.6  # 通过镜像python3.6启动一个名为python3的容器
    
docker exec -it python3 bash  # 进入容器python3

pip install django==1.11.11  # 在容器内安装django1.11.11

mkdir /project  # 在容器内创建/project文件夹

exit  # 退出容器

4.把宿主机中的项目拷贝到容器中（需要进入django项目所在的路径）

[root@yessir yessir1]# pwd  # 输出结果为：/opt/yessir1

[root@yessir yessir]# docker cp django_test/ 95d5:/project/ 

5.把容器id为95d5的容器做成镜像

docker commit 95d5 mydjango  # 把容器id为95d5的容器做成镜像，镜像名为mydjango

6.通过mydjango镜像运行实例出容器

docker run -di --name django_pro -p 8088:8088 mydjango python /project/django_test/manage.py runserver 0.0.0.0:8088
# 通过镜像mydjango进行端口映射 宿主机端口:容器端口 运行名为django_pro的容器，
# 后面可以跟执行的代码，但是路径必须配对，否则会报错

7.通过访问虚拟机ip:端口号 就能访问到该项目

2 dockerfile(很重要)

1.dockerfile本质

一个docker脚本文件，里面一堆指令，通过这个文件可以生成镜像，

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                      设置工作目录

Dockerfile部署django项目并用Nginx负载均衡

1.django项目中生成包含项目依赖包以及版本的requirements.txt文件

# requirements.txt

django==1.11.11
pymysql

2.在django项目下新建uwsgi.ini文件，输入配置内容

# uwsgi.ini

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

3.django项目中新建Dockerfile文件（名字必须叫Dockerfile），输入配置内容

# Dockerfile

FROM python:3.6
MAINTAINER yessir
EXPOSE 8080
ADD ./requirements.txt /home/
RUN pip install -r /home/requirements.txt -i https://pypi.douban.com/simple/ 
RUN pip install uwsgi -i https://pypi.douban.com/simple/
VOLUME ["/home"]
WORKDIR /home/django_test
# CMD ["uwsgi", "--ini", "/home/django_test/uwsgi.ini"] 
CMD ["python", "/home/django_test/manage.py", "runserver","0.0.0.0:8080"]

4.将django项目提交到gitte上（需要进入项目所在的路径下）

git init

git add .

git commit -m '项目初始化'

git remote add origin https://gitee.com/yessir_ye/django_test.git

git push -u origin master

5.在虚拟机中将django项目通过git clone从gitee上拉下来

cd /opt/

mkdir yessir

cd yessir

git clone https://gitee.com/yessir_ye/django_test.git
    

6.在虚拟机中构建镜像

cd /opt/yessir/django_test/

docker build -t mydjango:v1 .  
# -t表示tag，也就是给构建的镜像命名，:v1表示定义版本为v1版本  
# 通过当前目录下的Dockerfile构建一个名为mydjango的镜像，v1为版本号
# 注意不要忽略了v1后面的 . 否则会报错

7.查看镜像，通过镜像实例出容器

docker images

docker run -di --name django_pro -v /opt/yessir/:/home -p 8080:8080 mydjango:v1
      
docker run -di --name django_pro1 -v /opt/yessir/:/home -p 8081:8080 mydjango:v1

docker run -di --name django_pro2 -v /opt/yessir/:/home -p 8082:8080 mydjango:v1
            

8.通过访问宿主机对应端口即可访问到

9.通过Nginx转发

创建目录

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

新建Nginx配置文件

# 在nginx/conf文件夹下创建nginx.conf配置文件
vim /opt/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    10.0.0.200:8080;
        server    10.0.0.200:8081;
        server    10.0.0.200:8082;
    }
    server {
        listen       80;
        server_name  localhost;
        location / {
          #proxy_pass http://101.133.225.166:8080;
          #负载均衡配置
          proxy_pass http://node;
        }  
    }
}

另起一个docker容器运行nginx

docker run -di --name nginx -p 8888:80 -v /opt/nginx/conf/nginx.conf:/etc/conf/nginx.conf -v /opt/nginx/html:/etc/nginx/html -v /opt/nginx/logs:/var/log/nginx nginx

# 通过nginx进行端口转发 然后将不同的文件映射到docker容器中对应的文件路径下                

多启动几个docker容器

docker run -di --name=mydjango3 -v /opt/lqz/django_test2/:/home/django_test/ -p 8081:8080 django_1.11.11

docker run -di --name=mydjango4 -v /opt/lqz/django_test2/:/home/django_test/ -p 8082:8080 django_1.11.11
        
# 重启nginx
# 假设8081的容器挂了，8080的容器挂了，正常提供服务，
# 再把docker容器启动起来即可

docker-compose

下载官网：https://docs.docker.com/compose/install/

docker-compose是一个单机情况下容器编排的工具。

通过yml文件定义多个容器

通过一条命令根据yml去创建、管理这些容器

默认名字：docker-compose.yml

三个概念：Service、Networks、Volumes

一个service代表一个container，这个container可以从docker hub的image来创建，或者从本地dockerfile build的image来创建。

container创建的两种方式：

# 方式一：
1.利用docker hub的image来创建

# 方式二：
2.从本地的dockerfile build的image来创建

docker-compose有三个版本：1，2，3，目前都用"3"版本

5.1 安装

1.下载

Docker Compose 存放在Git Hub，不太稳定。 你可以也通过执行下面的命令，高速安装Docker Compose。

curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.4/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

2.通过上面的命令，安装完Docker Compose后，该文件是不可执行的，所以我们需要给他添加上可执行的权限

chmod +x /usr/local/bin/docker-compose  

3.校验是否安装成功

docker-compose -v  # 查看版本

5.2 docker-compose.yml如何配置

建议：在pycharm中创建：docker-compose.yml 文件来书写，会有提示

docker-compose.yml 如何写
version: '3'
services:
  wordpress:
    image: wordpress
    ports:
      - 8080:80
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_PASSWORD: root
    volumes:
      - mysql-data:/var/lib/mysql
                

3 docker-compose部署多应用

通过docker-compose部署flask，redis

1.创建Dockerfile

vim Dockerfile

Dockerfile配置

FROM python:3.6
COPY . /app
WORKDIR /app
RUN pip install flask redis
EXPOSE 5000
CMD [ "python", "app.py" ]

2.创建docker-compose.yml 文件

注意：yml类型的文件，要求每个冒号 : 和每个 - 符号后面必须有一个空格，否则会报错

vim docker-compose.yml

docker-compose.yml 配置

version: "3"
services:
  redis:
    image: redis
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - 8080:5000
    environment:
      REDIS_HOST: redis

3.创建app.py

vim app.py

在 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)

4.启动--运行

docker-compose up

这样，我们通过访问宿主机的8080端口，就能映射到docker容器中的5000端口，如下图所示：

 5.4 docker-compose 水平扩展

把上面的flask_redis项目扩展成3个容器（原来只有1个容器）,需要做以下事情：

1.app.py改成监听的端口为80

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=80, debug=True)

2.docker-compose.yml文件修改如下：

web不再做端口映射，添加lb负载均衡器，在lb里面进行端口转发

version: "3"  
services:
  redis:
    image: redis
  web:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      REDIS_HOST: redis
  lb:
    image: dockercloud/haproxy
    links:
      - web
    ports:
      - 8080:80
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

3.启动，并在浏览器查看

docker-compose up

4.把web扩展为3个，在浏览器查看

docker-compose up --scale web=3 -d

而且每次访问的端口主机名都不一样，因为有用haproxy进行负载均衡，并且能看到多了2个容器

5.把web减到1个，从浏览器查看

docker-compose up --scale web=1 -d

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