目录

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

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

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

# 此时通过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

实现负载均衡将并发负载给不同的服务器

![跨域处理](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.创建容器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

Dockerfile指令与Docker-compose容器编排-搭建docker私有仓库的更多相关文章

  1. AspNetCore容器化(Docker)部署(三) —— Docker Compose容器编排

    一.前言 上一篇部署了一个最基础的helloworld应用,创建了两个容器和一个network,还算应付得过来. 如果该应用继续引入mysql.redis.job等若干服务,到时候发布一次得工作量之大 ...

  2. Docker容器之搭建本地私有仓库

    Docker容器之搭建本地私有仓库 本地私有仓库搭建的具体步骤 首先下载 registry 镜像 docker pull registry 在 daemon.json 文件中添加私有镜像仓库的地址并重 ...

  3. Docker Compose 容器编排 NET Core 6+MySQL 8+Nginx + Redis

    环境: CentOS 8.5.2111Docker 20.10.10Docker-Compose 2.1.0 服务: db  redis  web nginx NET Core 6+MySQL 8+N ...

  4. Docker Compose容器编排

    Compose是Docker官方的开源项目,可以实现对Docker容器集群的快速编排.Compose 中有两个重要的概念:服务(service):一个应用的容器,实际上可以包括若干运行相同镜像的容器实 ...

  5. Docker Compose 容器编排

    1. 前言 Docker Compose 是 Docker 容器进行编排的工具,定义和运行多容器的应用,可以一条命令启动多个容器. 使用Compose 基本上分为三步: Dockerfile 定义应用 ...

  6. 八、docker compose容器编排

    一. Docker-Compose 1.1. 什么是Docker Compose Compose 项目是 Docker 官方的开源项目,负责实现 Docker 容器集群的快速编排,开源代码在 http ...

  7. Docker 容器编排利器 Docker Compose

    Compose 简介 通过前面几篇文章的学习,我们可以通过 Dockerfile 文件让用户很方便的定义一个单独的应用容器.然而,在日常工作中,经常会碰到需要多个容器相互配合来完成某项任务的情况,例如 ...

  8. asp.net core容器&mysql容器network互联 & docker compose方式编排启动多个容器

    文章简介 asp.net core webapi容器与Mysql容器互联(network方式) docker compose方式编排启动多个容器 asp.net core webapi容器与Mysql ...

  9. 实战maven私有仓库三部曲之三:Docker下搭建maven私有仓库

    本章是<实战maven私有仓库>系列的第三篇,在前两章中,我们先在linux搭建maven私有仓库,然后在开发环境使用此仓库,本章我们在docker下快速搭建maven私有仓库,然后像前面 ...

随机推荐

  1. pandas学习总结

    什么是pandas pandas数据读取 03. Pandas数据结构 Pandas查询数据的几种方法

  2. 二十三、原理图和PCB交互式布局

    上图 在原理图里面直接选择在PCB里面就可以移动了,大功告成

  3. CSS5:移动端页面(响应式)

    CSS5:移动端页面(响应式) 如果手机端和PC端页面差别很大,就不要写响应式,不要写@media 就直接将两个页面拆开成两个文件就可以了.关于判断是手机端你还是PC端,就交给后端来做只有一些新闻站点 ...

  4. css文字颜色渐变的3种实现

    在web前端开发过程中,UI设计师经常会设计一些带渐变文字的设计图,在以前我们只能用png的图片来代替文字,今天可以实现使用纯CSS实现渐变文字了.下面就介绍3中实现方式供大家参考! 基础样式: .g ...

  5. 使用Google Closure Compiler高级压缩Javascript代码

    背景 前端开发中,特别是移动端,Javascript代码压缩已经成为上线必备条件. 如今主流的Js代码压缩工具主要有: 1)Uglify http://lisperator.net/uglifyjs/ ...

  6. 手把手教你从零写一个简单的 VUE

    本系列是一个教程,下面贴下目录~1.手把手教你从零写一个简单的 VUE2.手把手教你从零写一个简单的 VUE--模板篇 今天给大家带来的是实现一个简单的类似 VUE 一样的前端框架,VUE 框架现在应 ...

  7. 前端每日实战:133# 视频演示如何用 CSS 和 GSAP 创作有多个关键帧的连续动画

    效果预览 按下右侧的"点击预览"按钮可以在当前页面预览,点击链接可以全屏预览. https://codepen.io/comehope/pen/eLMKJG 可交互视频 此视频是可 ...

  8. java中StringBuffer的用法

    2.StringBuffer StringBuffer:String类同等的类,它允许字符串改变(原因见上一段所说).Overall, this avoids creating many tempor ...

  9. ubantu之Git使用

    本文讲述在Ubuntu 14.04 x64环境下,如何安装Git,配置连接GitHub,并且上传本地代码到github. 一. 注册Git账户以及创建仓库 要想使用github第一步当然是注册gith ...

  10. 获取bootstrap模态框点击的对应项(e.relatedTarget.dataset)

    //获取绑定的自定义属性值<ul> <li data-toggle="modal" data-index="电表1111" data-targ ...