Dockerfile指令與Docker-compose容器編排-搭建docker私有倉庫

一:部署應用映射外部目錄(持久化)

# 部署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