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

目錄

• 一:部署應用對映外部目錄(持久化)
  • 總結
• 二:遷移與備份(容器儲存為映象)
  • 1.django執行gitee，專案提交到遠端
  • 2.其他操作
  • 3.操作步驟
  • 4.容器儲存為映象
  • 5.把映象打包成壓縮包
  • 6.把壓縮包回覆為映象
  • 7.容器內查詢全部安裝軟體
  • 8.總體程式碼（遷移與備份(容器儲存為映象)）
• 三:Dockerfile和指令講解
  • 1.簡介Dockerfile
  • 2.Dockerfile基礎指令
  • 3.解析:
  • 4.其他一些指令：
• • • • 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裡的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