文章目录
- 一、应用部署
- 1.MySQL部署
- 2.Redis部署
- 3.Nginx部署
- 二、迁移与备份
- 1.容器做成镜像
- 2.镜像备份和恢复(打包成压缩包）
- 三、DockerFile
- 0.镜像从哪里来？
- 1.什么是DockerFile
- 2.DockerFile 构建特征
- 3.DockerFile命令描述
- 4.构建一个带vim的centos镜像案例
- 5.DockerFile构建Django项目
- 四、docker私有仓库
- 1.镜像传到官方仓库
- 2.镜像分层
- 3.私有仓库创建
- docker搭建私有仓库(registry，这个是没有图形化界面)
- 五、Docker-Compose介绍及下载
- 1.介绍docker-compose
- 2.下载docker-compose
- 3.docker-compose常用命令
- 六、使用docker-compose部署flask-redis项目
一、应用部署
1.MySQL部署
'在dokcer中部署mysql，以后不需要在宿主机上装mysql'
1.做端口映射
docker run -id --name=mysql5.7 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=1234 mysql:5.7
2.做目录映射
-如果没有做目录映射，在mysql容器中表数据一旦删除就所有都没有了，一旦做了目录映射，重新创建相同的,数据会在里面还在
1.docker pull mysql:5.7 拉取镜像
2.mkdir /mysql # 创建文件夹数据分离 在根目录下
mkdir /mysql/conf.d
mkdir /mysql/data/
'创建好文件 写入配置'
3.vim /mysql/my.cnf # 如果在宿主机上没有安装vim，就使用vi创建
'写入数据，就是和本机上面安装的mysql的配置文件差不多参数'
[client]
default-character-set=utf8
[mysqld]
user=mysql
character-set-server=utf8
default_authentication_plugin=mysql_native_password
secure_file_priv=/var/lib/mysql
expire_logs_days=7
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
max_connections=1000
4.做目录映射 # 基于镜像运行成容器 端口映射3306 目录映射
docker run -di -v /mysql/data/:/var/lib/mysql -v /mysql/conf.d:/etc/mysql/conf.d -v /mysql/my.cnf:/etc/mysql/my.cnf -p 3307:3306 --name mysql5.7 -e MYSQL_ROOT_PASSWORD=1234 mysql:5.7
5.本地链接好容器mysql5.7，创建库、创建表，插入数据
6.关闭容器，删除容器，这样mysql的容器就没有了，但是数据还在宿主机上放着
docker stop mysql5.7
docker rm mysql5.7
'这个时候删除容器 数据还在 只需要再创建一个新的容器 做好目录映射就可以继续使用了,目录保持一致，密码保持一致'
2.Redis部署
1.docker pull redis # 拉取redis镜像,不写版本默认latest
2.mkdir /root/data # 根目录创建data文件夹
3.vim /root/redis.conf # 创建并编辑redis配置文件
bind 0.0.0.0
daemonize NO
protected-mode yes
requirepass 1234
4.运行创建
-启动容器时，运行的命令是什么 redis-server /etc/redis/redis.conf
-在容器运行时，可以自己定制运行命名 举例：docker run -id centos:centos7 ls
docker run -id -p 6379:6379 --name redis -v /root/redis.conf:/etc/redis/redis.conf -v /root/data:/data redis redis-server /etc/redis/redis.conf
5.运行redis容器，并写入数据，用本地能链接redis的软件链接一下查看,或者直接cmd链接
docker exec -it redis /bin/bash
'容器redis链接'
redis cli # 链接
auth xxxx # 密码
'cmd窗口链接查看'
redis-cli -h ip地址 -p 端口号
auth 密码
'resp链接：填入链接名称(随意填)、地址、密码即可'
3.Nginx部署
1.docker pull nginx # 拉取nginx镜像
'没做映射操作'
2.docker run -id --name=nginx -p 80:80 nginx # run起容器
3.从win机器浏览器可以访问：xx.xxx.xx:80
4.进入容器内部，修改index /usr/share/nginx/html
docker exec -it nginx /bin/bash
5.修改index.html
vi、vim、yum都没有因为不是Centos系统
apt-get update
apt-get install vim
'做映射操作'
6.做目录映射
# /usr/share/nginx/html
-docker run -id --name nginx1 -p 8088:80 -v /root/html:/usr/share/nginx/html nginx
-cd /root/html
-vi index.html 随便填入html文本 <h1>hello world!</h1>
-进入到容器内部后到/usr/share/nginx/html目录就可以看到映射过来的index.html文件了
'以后只需要修改宿主机的/root/html 路径，看到页面就是修改后的'
二、迁移与备份
1.容器做成镜像
-镜像从哪来的？
1 docker pull 拉的
2 通过容器打包成镜像
-centos镜像运行成容器---》装了vim
-把装了vim的容器---》打包成镜像
-以后拿到这个镜像--》再运行成容器，都会带vim命令
3 Dockerfile构建
-容器保存为镜像
-运行一个centos容器
docker run -id --name centos_vim centos:centos7
-在容器中装vim
docker exec -it a6e240 /bin/bash
yum install vim -y
-把容器做成镜像（centos+vim） 需要退出容器，在宿主机上操作
docker commit 容器名 镜像名
docker commit centos_vim centos_vim
-把centos_vim 容器删除
docker rm centos_vim -f
-基于新构建的镜像，运行成容器
docker run -id --name centos_vim centos_vim:latest
-进入到容器中，查看，软件都在
docker exec -it c3e633bd1 /bin/bash
2.镜像备份和恢复(打包成压缩包）
'镜像的备份和恢复'
-把镜像做成压缩包
docker save -o 压缩包名 镜像名/镜像id
docker save -o mynginx.tar nginx # 把镜像做成tar文件
-删除原有镜像
-把备份的镜像恢复
docker load -i 压缩包名
docker load -i mynginx.tar # 把压缩包load成镜像
三、DockerFile
0.镜像从哪里来？
1 远程仓库拉取的 docker pull （hub.docker---》搭建私有仓库）
2 用容器做成的镜像 docker commit
3 把备份的恢复 docker load
4 使用Dockerfile来构建(这种多)
1.什么是DockerFile
Dockerfile其实就是根据特定的语法格式撰写出来的一个普通的文本文件
利用docker build命令依次执行在Dockerfile中定义的一系列命令，最终生成一个新的镜像（定制镜像）文件名必须叫Dockerfile。
Dockerfile是由一系列命令和参数构成的脚本，这些命令应用于基础镜像并最终创建一个新的镜像。
- 对于开发人员：可以为开发团队提供一个完全一致的开发环境；
- 对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像开始工作了；
- 对于运维人员：在部署时，可以实现应用的无缝移植。
2.DockerFile 构建特征
1.DockerFile必须具备一个FROM命令来进行构建
2.每一个Dockerfile命令都会构建一层镜像（本质上是每一层都会启动一个容器，执行完命令后，将容器进行提交后，产生新的镜像层）
3.通过查看下载下来的镜像，发现历史层信息的层ID是missing，其实是因为原本的层id只存在于构建镜像的宿主机上，一旦转移镜像后，历史层消息中将只保留最新一层的ID
3.DockerFile命令描述
详细指令介绍：https://zhuanlan.zhihu.com/p/419175543
'常用命令'
FROM: 指定基础镜像
RUN： 构建镜像过程中需要执行的命令。可以有多条。docker build
CMD：添加启动容器时需要执行的命令。多条只有最后一条生效。可以在启动容器时被覆盖和修改
ENTRYPOINT：同CMD，但这个一定会被执行，不会被覆盖修改。
：为镜像添加对应的数据。
MLABELAINTAINER：表明镜像的作者。将被遗弃，被LABEL代替。
ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效
ARG：设置只在构建过程中使用的环境变量，构建完成后，将消失
ADD：将本地文件或目录拷贝到镜像的文件系统中。能解压特定格式文件，能将URL作为要拷贝的文件
COPY：将本地文件或目录拷贝到镜像的文件系统中。
WORKDIR：设置工作目录
'''不怎么常用命令'''
EXPOSE：设置对外暴露的端口。
VOLUME：添加数据卷
USER：指定以哪个用户的名义执行RUN, CMD 和ENTRYPOINT等命令
ONBUILD：如果制作的镜像被另一个Dockerfile使用，将在那里被执行Docekrfile命令
STOPSIGNAL：设置容器退出时发出的关闭信号。
HEALTHCHECK：设置容器状态检查。
SHELL：更改执行shell命令的程序。Linux的默认shell是[“/bin/sh”, “-c”]，Windows的是[“cmd”, “/S”, “/C”]。
'CMD与ENTRYPOINT'
1.相同点：
只能写一条，如果写了多条，那么只有最后一条生效。
容器启动时才运行，运行时机相同。
2.不同点：
ENTRYPOINT不会被运行的command覆盖，而CMD则会被覆盖。
如果我们在Dockerfile中同时写了ENTRYPOINT和CMD，并且CMD指令不是一个完整的可执行命令，那么CMD指定的内容将会作为ENTRYPOINT的参数
'ARG 和 ENV'
ENV：设置执行命令时的环境变量，并且在构建完成后，仍然生效
ARG：设置只在构建过程中使用的环境变量，构建完成后，将消失
4.构建一个带vim的centos镜像案例
'构建一个带vim的centos:7镜像,根路径下有/jack/xx.py'
1.在宿主机上创建一个文件(文件名必须叫Dockerfile)，文件里面书写下面的
-vim Dockerfile
'''
ENV 环境变量
touch 创建文件
echo 输出 等同于print
echo 'xxx' > /xx.py > 就是放入到指定文件中
mv 1.txt test.txt mv移动，也可以是重命名
copy 复制到指定文件中
workdir jack 工作目录，创建完毕后进入时会直接进入到这个目录
'''
FROM centos:centos7
MAINTAINER WhiteG
ENV name jack
RUN yum install vim -y &&\
mkdir /jack &&\
touch /jack/xx.py &&\
echo 'print(hello world)' > /jack/xx.py
COPY ./test.txt /jack/test.txt
WORKDIR /jack
'''
注意如果在这里使用了CMD命令，例如CMD ['python' './jack/xx.py']，
运行容器时会默认加上 /bin/bash -c(可以在docker images 的COMMAND看) 这个是以shell形式，运行时，linux默认会加上的
'''
'然后保存退出，也可以查看一下 cat Dockerfile是否修改内容成功'
2.基于dockerfile构建镜像, '.' 是基于当前路径下的Dockerfile 构建镜像
-docker build -t='centos_jack_vim' .
3.可以查看是否构建成功镜像 docker images
4.基于这个构建的镜像运行成容器
# 因为建构的镜像没有写版本，默认就是latest，只要是latest，可写可不写
- docker run -id --name xx centos_jack_vim:latest
'上面的CMD命令方式运行，会自动加上/bin/bash -c 所以我们可以修改直接在把镜像运行成容器时添加启动命令即可'
'docker run -id --name xx centos_jack_vim python /jack/xx.py'
5.进入到容器内
-docker exec -it xx /bin/bash
6.验证vim，和文件夹，文件是否存在
-使用python的方式查看环境变量
1.python中，导入模块 import os
2.os.environ.get('name') # 获取对应环境变量
-使用shell命令查看环境变量
echo $name # 使用echo输出即可
5.DockerFile构建Django项目
'在公司中，使用Docker开发的工作流程：'
1.开发完一个Django项目
2.然后在项目路径下新建Dockerfile，编辑下面内容：
FROM python:3.8
MAINTAINER WhiteG
WORKDIR /soft
COPY ./requirements.txt /soft/requirements.txt
RUN pip install -r requirements.txt -i https://pypi.doubanio.com/simple
CMD ["python","manage.py","runserver","0.0.0.0:8080"]
3.把代码提交到git/或者私有仓库中
'这里我以git 为例'
-git init # 初始化
-然后git仓库创建新的空仓库，然后粘贴对应的命令
-git add .
-git commit -m '' # 提交到版本库
-git push origin master
4.在部署项目的机器上，clone（克隆）项目
-在部署项目的机器上安装 yum install git
-git clone https://gitee.com/xxxx/xxxxx.git
5.构建镜像 ，cd到对应的文件夹中 执行构建命令
-docker build -t='django_books' . # 点表示从当前路径的Dockerfile中构建镜像
6.把刚刚构建的镜像运行成容器，并做目录映射、端口映射
-docker run -id --name=books -v /root/docker_books:/soft -p 8080:8080 django_books:latest
"""
如果镜像不是django_books目录下构建的，它是找不到dockerfile文件的
解决方法：停止容器 删除容器 删除镜像 切到books下新构建新镜像
"""
7.这样直接访问宿主机的8080端口就能看到项目的前端页面了
8.后续只需要开发人员继续提交代码到仓库(push)
9.运维人员在部署的机器上拉取仓库代码(pull)，然后重启容器，这样就可以直接看到最新的页面了
-注意需要再第一次拉取的项目文件夹中拉取，否则无效
-cd docker_books
-git pull origin master
-docker restart books # 重启容器
'''
注意：如果是开发修改了项目依赖,然后修改requirements.txt，就需要重写构建镜像，然后在运行容器的操作了，
如果是开发修改代码逻辑，为了做版本区分，也是需要做新版本镜像，这样也是需要重构新镜像
'''
四、docker私有仓库
docker官方提供的远程仓库，可以把自己定义的镜像传上去，就是自己的私有镜像（可公开）。公司做的镜像一般不放在远程仓库，会放在公司自己搭建私有仓库（把公司制作的镜像传到私有仓库）
1.镜像传到官方仓库
第0步：在远端创建仓库
第一步：给镜像打标签
docker tag 本地镜像名:标签 你的名字/镜像名字:标签
例如：docker tag centos:centos7 0jchen/centos7:latest
第二步：登录到远程仓库(官方的hub.docker)
docker login # 输入注册的docker官方账号和密码
第三步：将镜像提交docker远程仓库
docker push 0jchen/centos7:latest
第四步：别人就可以下载了
docker pull 0jchen/centos7:latest
2.镜像分层
每一个
Dockerfile命令都会构建一层镜像（本质上是每一层都会启动一个容器，执行完命令后，将容器进行提交通过查看下载下来的镜像，发现历史层信息的层ID是missing，其实是因为原本的层id只存在于构建镜像的宿主机上，一旦转移镜像后，历史层消息中将只保留最新一层的ID.
'只要执行一个命令就会多一层，例如：'
-RUN yum install vim -y
-RUN yum install git -y
-这样就会多出好几层，这也是为什么我上面的一个案例里面会把RUN命令都合并的写(&&)，这样能减少镜像分层的层数
'查看镜像分层的命令'
docker history 镜像名:版本
'而分层少的的好处：构建快，分发方便，如果本地有某一层了，这一层就不需要下载了'
'所以以后：Dockerfile写命令，建议多条命令合为一条，这样就只会生成一层，例如：'
-使用了\就是换行，这样在Dockerfile文件中就可以换行写，不然就只能一行的写，观看效果不好
RUN python -m pip install --upgrade pip &&\
python -m pip install --upgrade setuptools &&\
pip install -r requirements.txt
3.私有仓库创建
企业级的私有仓库Harbor (有图形化界面，跟hub.docker 很像)，harbor部署与使用具体自行搜索即可
docker搭建私有仓库(registry，这个是没有图形化界面)
'Harbor就是封装了Docker的registry v2，然后做了图形化界面'
这里就演示搭建一个registry私有仓库
'搭建步骤：(使用docker搭建docker私有仓库)'
1.拉取registry镜像
docker pull registry
2.registry镜像运行成容器
docker run -di --name=registry -p 5000:5000 registry
3.这是个web服务端，所以需要从浏览器中访问它
-打开浏览器 输入地址http://10.0.0.110:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空
4.修改daemon.json
vi /etc/docker/daemon.json # 这个之前创建的时候配置过国内镜像下载
# 配置私有仓库的地址，就是ip地址+端口号
{
"insecure-registries":["10.0.0.110:5000"]
}
5.重启docker和重启容器，让配置生效
systemctl restart docker
docker start registry
6.把某个镜像tag成私有仓库的镜像
docker tag 镜像名字/id IP地址:端口/私有仓库镜像名:版本 # 版本可以不填，默认latest
docker tag django_books 10.0.0.110:5000/django_books
7.提交到私有仓库
docker push 10.0.0.110:5000/django_books
8.其他人，只要配置了私有仓库就可以直接拉取
docker pull 10.0.0.110:5000/django_books
五、Docker-Compose介绍及下载
1.介绍docker-compose
使用docker部署项目时，会存在一个问题，例如一个Django项目中，把mysql、redis都放在一个容器中，之后不好使用服务，如果每个服务放在一个容器，批量管理多个容器，比较难操作，于是出现了
docker-compose
docker-compose是一个能一次性定义和管理多个Docker容器的工具，单机容器编排【定义和管理】。Compose中定义和启动的每一个容器都相当一个
服务（service)，Compose中能定义和启动多个服务，且它们之间通常具有协同关系。管理方式：
- 使用YAML文件来配置我们应用程序的服务。
- 使用单个命令（docker-compose up），就可以创建并启动配置文件中配置的所有服务。
多容器编排的工具：
-docker swarm：公司里用的不多
-k8s是多机容器编排工具，go语言写了k8s
2.下载docker-compose
安装docker-compose （可执行文件，放在了github上，下载下来即可，速度很慢）
https://github.com/docker/compose/releases
'然后找到自己想要的对应版本的docker-compose复制链接即可，例如docker-compose-linux-x86_64 v2.24.6版本'
https://github.com/docker/compose/releases/download/v2.24.6/docker-compose-linux-x86_64
-使用压缩包形式下载
1.在docker上安装yum install wget -y
wget https://github.com/docker/compose/releases/download/v2.24.6/docker-compose-linux-x86_64
2.本地下载上传到docker上
'因为去github官方下载很慢，所以我这里选择自己在本地下载好，使用yum install lrzsz软件'
rz 从本地文件中导入进来
-复制目录
'想在任意路径下执行docker-compose都有相应反应，就需要把可执行文件放到环境变量所在的目录下'
cp ./docker-compose /usr/local/bin/docker-compose
/usr/local/bin/ 这个目录就是在环境变量当中
-给执行的权限
chmod +x /usr/local/bin/docker-compose
'''
+x linux中的执行权限，具体可自行查找资料
ls -al 查看权限
rwx rwx rwx
属主 属组 其他
r：read 读权限
w：wirte 写权限
x：执行权限
chmod +x 表示添加执行权限
chmod +r 表示添加读权限
chmod +w 表示添加写权限
属主 属组 所有人
chmod 777 文件名 777就是最高权限三个rwx全都有
--------------------
rwx rwx rwx
000 000 000 使用二进制来表示每个rwx的三位，二进制只有0、1
(逢二进一[第一位需要到二就第二位为一]，到第二位进第三位也是逢二进一)，所以一个rwx就需要7，因此三个rwx就是777
例如：chmod 555 文件名
当rwx中有为零的则用-表示，如果全为零---表示
r-x r-x r-x
101 101 101
这个例子就是表示只有当前文件的所有的读权限和执行权限
'''
-这样以后在任意位置敲docker-compose都可以
'''
补充：使用epel源 （epel源为“红帽系”的操作系统提供的额外的软件包，适用于RHEL，CentOS）
我们正常下载就去centos系统对应的仓库下载(别的系统就去它对应的系统仓库下载)
但是仓库的软件不够全面，只提供了一些常规的
这就是为什么要使用epel源，epel源，是一个扩展源，这个源仓库软件非常多，像nginx、redis等等都可以直接下载
这个源唯一的缺点就是不能指定下载的镜像版本
具体如何下载及配置自行查找资料，yum install -y epel-release 安装
'''
3.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部署flask-redis项目
flask项目，使用redis服务---->2个容器
1. 新建flask项目app.py
from flask import Flask
from redis import Redis
import os
app = Flask(__name__)
# redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
# 容器的主机名---》flask容器和redis容器是能ping通的（同一个网段），可以通过ip ping 也可以通过主机名ping
redis = Redis(host='redis', port=6379)
@app.route('/')
def hello():
redis.incr('hits')
return '你好! 查看 %s 次\n' % (redis.get('hits'))
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000, debug=True)
2. 编写Dockerfile构建flask项目
FROM python:3.9
WORKDIR /app
COPY . /app
RUN pip install flask redis -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
EXPOSE 5000
CMD [ "python", "app.py" ]
# 构建出镜像，一会统一使用 docker-compose构建
3. 编写docker-compose 的yml文件docker-compose.yml
'注意，必须要缩进好'
version: "3"
services:
redis:
image: redis
web:
build:
context: .
dockerfile: Dockerfile
ports:
- 8080:5000
environment:
REDIS_HOST: redis
4. docker-compose启动
1.使用docker-compose构建并启动(一键部署：redis，和flask ，每个都在一个容器中)
docker-compose up
2.ping redis 连接
# 进入到了web，ping redis
# 安装ping命令，
apt-get update
apt-get install inetutils-ping
ping redis
3.这样删除后，在使用docker-compose up可以直接一键自动部署好
docker-compose up
-构建flask镜像
-reids镜像如果不存在，就会拉取
-启动flask
-启动redis
