Docker学习笔记

# 1，卸载旧版本
 sudo dnf remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

# 2，需要的安装包和进项仓库
 sudo dnf -y install dnf-plugins-core
 sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 正确推荐使用国内的
 yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 3,更新yum软件包索引
yum makecache fast


#3，安装docker   docker-ce 社区版 docker-ee企业版 
sudo dnf install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 4，启动docker
 sudo systemctl enable --now docker /systemctl start doucker   

# 5,运行hello-world
sudo docker run hello-world

得到如下界面，则安装成功了

bash 复制代码

# 6，查看一下下载的 hello-world镜像
docker images

III，卸载Docker

bash 复制代码

# 1，卸载依赖
 sudo dnf remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras


# 2，删除资源
 sudo rm -rf /var/lib/docker
 sudo rm -rf /var/lib/containerd

#/var/lib/docker    docker的默认工作路径

Ⅳ，阿里云镜像加速

登录容器镜像服务控制台即可找到对应配置

bash 复制代码

sudo mkdir -p /etc/docker    #新建一个docker目录

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://yxzrazem.mirror.aliyuncs.com"]
}
EOF    #在/daemon.json中配置一个阿里云地址

sudo systemctl daemon-reload   #镜像重启

sudo systemctl restart docker    #docker重启

Ⅴ，docker运行run的流程图

Ⅵ，底层原理

3，Docker命令

I，帮助命令

bash 复制代码

docker version  #显示docker版本信息
docker info     #显示docker更详细的一些系统信息，，包括镜像的容器数量
docker --help  #万能命令，看docker的所有命令
docker xx --help  # xx命令的所有参数解释  docker images --help

帮助文档：docker | Docker Docs

II，镜像命令

docker images 查看虽有本地的主机上的镜像

bash 复制代码

[root@xhm ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED       SIZE
hello-world   latest    feb5d9fea6a5   3 years ago   13.3kB

#解释
REPOSITORY    镜像的仓库源
TAG           镜像的标签
IMAGE ID      镜像的id
CREATED       镜像的创建时间
SIZE          镜像的大小

#可选项
 -a, --all            #列出所有镜像
 -q, --quiet          #只显示镜像id

docker search mysql 搜索镜像

bash 复制代码

docker search mysql 

docker search mysql --filter=STARS=3000  #过滤STARS>3000的

docker pull下载镜像

bash 复制代码

# 下载镜像 docker pull 镜像名[:tag]
docker pull mysql

[root@xhm ~]# docker pull mysql
Using default tag: latest   #如果不写tag. 默认就是  latest
latest: Pulling from library/mysql
72a69066d2fe: Pull complete    #分层下载   docker image的核心联合文件系统
93619dbc5b36: Pull complete 
99da31dd6142: Pull complete 
626033c43d70: Pull complete 
37d5d7efb64e: Pull complete 
ac563158d721: Pull complete 
d2ba16033dad: Pull complete 
688ba7d5c01a: Pull complete 
00e060b6d11d: Pull complete 
1c04857f594f: Pull complete 
4d7cfa90e6ea: Pull complete 
e0431212d27d: Pull complete 
Digest: sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709   #签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest #真实地址


#两个等价
docker pull mysql
docker.io/library/mysql:latest

#有版本的
docker pull mysql:5.7

docker rmi 删除镜像

bash 复制代码

rm  删除  i    image镜像

docker rmi 镜像id  #单个删除

docker rmi-f 镜像id 镜像id 镜像id #多个删除

docker rmi-f $(docker images -aq)  #docker images -aq查出所有镜像，全部删除

III，容器命令

前提：有了镜像才可以创建容器，linux,下载一个centos镜像来测试学习

bash 复制代码

docker pull centos

新建容器并启动

bash 复制代码

docker run [可选参数] image

#参数说明

--name="Name"  容器名字 tomcat01   tomcat02   用来区分容器
-d             后台方式运行
-it            使用交互方式运行，进入容器查看内容
-p             指定容器的端口  -p 8080:8080
    -p ip:主机端口:容器端口
    -p 主机端口:容器端口(常用)
    -p 容器端口
    容器端口
-P            随机指定端口


#测试
#启动并进入容器 
[root@xhm ~]# docker run -it centos /bin/bash
[root@5d122a82a90a /]# exit   #退出容器

列出所有运行的容器

bash 复制代码

docker ps 命令
    #列出当前正在运行的容器

-a  #列出当前正在运行的容器+带出历史运行过的容器
-n=num  #显示最近常见的num条容器
-q   #只显示容器的编号

退出容器

bash 复制代码

exit  #直接容器停止并退出
Ctrl + P + Q  #容器不停止退出

删除容器

bash 复制代码

docker rm 容器id  #删除指定容器，不能删除正在运行的容器，如果要强制删除就是rm -f
docker rm -f $(docker ps -aq)   #删除所有容器
docker ps -q|xargs docker rm    #一样可以删除全部容器

启动和停止容器的操作

bash 复制代码

docker start  #启动容器

docker restart #重启容器

docker stop  #停止正在运行的容器

docker kill  #杀掉容器

Ⅳ，常用的其他命令

后台启动容器

bash 复制代码

#docker run -d 镜像名
docker run -d centos

#问题docker ps 发现centos停止了

#常见坑，docker容器用后台运行，就必须有一个前台进程，docker这里发现没有前台应用，就会自动停止

查看日志

bash 复制代码

docker logs

docker log -tf --tail 10 镜像id 
 # tail num   num   条,没有就是全部
 # -tf   显示日志

#没有日志，自己编写一段shell脚本
#"while true;do ehco xhm;sleep 1 
#-c写入东西
docker run -d centos /bin/sh - c"while true;do echo xhm;sleep 1;done"

查看容器里面的进程信息

bash 复制代码

docker top 容器id
#查看容器内部的进程信息

查看镜像的元数据

bash 复制代码

docker inspect 容器id

进入当前正在运行的容器

bash 复制代码

方式1
# 我们通常容器都是使用后台方式运行的，需要进入容器修改一些配置

#命令
docker exec -it 容器id /bin/bash

bash 复制代码

方式2
docker attach 容器id

bash 复制代码

两种方式的区别

# docker exec      #进入容器后就开一个新的终端，可以在里面操作（常用）
# docker attach    #进入容器正在执行的终端，不会启动新的进程

从容器内拷贝文件到主机

容器内外式互相隔离的，所以此处就有此需求

bash 复制代码

docker cp 容器id:容器内路径 目的主机路径

[root@9d3ab87bc01a home]# touch xhm.java #在容器内新建一个文件
[root@xhm home]# docker cp 9d3ab87bc01a:/home/xhm.java /home  #将容器的文件拷贝出来到主机

每个命令，如果不清楚参数使用可参考官方文档docker search | Docker Docs，或者使用docker 命令 --help查看

Ⅴ，命令小结（可查）

bash 复制代码

###帮助命令
docker version  #显示docker版本信息
docker info     #显示docker更详细的一些系统信息，，包括镜像的容器数量
docker --help  #万能命令，看docker的所有命令
docker xx --help  # xx命令的所有参数解释  docker images --help

####镜像命令
docker images
    #可选项
     -a, --all            #列出所有镜像
     -q, --quiet          #只显示镜像id
docker search mysql 
docker search mysql --filter=STARS=3000  #过滤STARS>3000的

#下载镜像 docker pull 镜像名[:tag]
docker pull mysql
#两个等价
docker pull mysql
docker.io/library/mysql:latest

#有版本的
docker pull mysql:5.7

#删除镜像
#rm  删除  i    image镜像
docker rmi 镜像id  #单个删除
docker rmi-f 镜像id 镜像id 镜像id #多个删除
docker rmi-f $(docker images -aq)  #docker images -aq查出所有镜像，全部删除

####容器命令
#启动容器
docker run [可选参数] image
#参数说明
--name="Name"  容器名字 tomcat01   tomcat02   用来区分容器
-d             后台方式运行
-it            使用交互方式运行，进入容器查看内容
-p             指定容器的端口  -p 8080:8080
    -p ip:主机端口:容器端口
    -p 主机端口:容器端口(常用)
    -p 容器端口
    容器端口
-P            随机指定端口

#启动并进入容器 
docker run -it centos /bin/bash


#列出当前正在运行的容器
docker ps 命令
    -a  #列出当前正在运行的容器+带出历史运行过的容器
    -n=num  #显示最近常见的num条容器
    -q   #只显示容器的编号

#退出容器
exit  #直接容器停止并退出
Ctrl + P + Q  #容器不停止退出

#删除容器
docker rm 容器id  #删除指定容器，不能删除正在运行的容器，如果要强制删除就是rm -f
docker rm -f $(docker ps -aq)   #删除所有容器
docker ps -q|xargs docker rm    #一样可以删除全部容器


#启动和停止容器的操作
docker start  #启动容器
docker restart #重启容器
docker stop  #停止正在运行的容器
docker kill  #杀掉容器

####其他命令

#后台启动
#docker run -d 镜像名
docker run -d centos
docker logs

#查看日志
docker logs -tf --tail 10 镜像id 
 # tail num   num   条,没有就是全部
 # -tf   显示日志

#没有日志，自己编写一段shell脚本
#"while true;do ehco xhm;sleep 1 
#-c写入东西
docker run -d centos /bin/sh - c"while true;do echo xhm;sleep 1;done"

#查看容器里进程信息
docker top 容器id

# 查看镜像的元数据
docker inspect 容器id

#进入当前正在运行的容器
#方式1
# 我们通常容器都是使用后台方式运行的，需要进入容器修改一些配置
#命令
docker exec -it 容器id /bin/bash
#方式2
docker attach 容器id
#两种方式的区别
# docker exec      #进入容器后就开一个新的终端，可以在里面操作（常用）
# docker attach    #进入容器正在执行的终端，不会启动新的进程

#从容器内拷贝文件到主机
docker cp 容器id:容器内路径 目的主机路径

touch xhm.java #在容器内新建一个文件
docker cp 9d3ab87bc01a:/home/xhm.java /home  #将容器的文件拷贝出来到主机

docker stats  查案cpu状态

练习1：Docker安装nginx

1,搜索镜像 docker search nginx (do)

2,下载镜像 docker pull nginx

3,运行镜像 docker run -d --name nginx01 -p 3344:80 nginx

-d 后台运行

--name 给容器命名

-p 宿主机端口：容器内部端口（端口暴露）

4,本地测试镜像 curl localhost:3344

5,公网地址：3344则可访问

端口暴露的概念 -p 3344:80

(服务器防火墙需开通3344端口，阿里云镜像也需要开通端口3344)

bash 复制代码

防火墙查看端口：firewall-cmd --list -ports

防火墙开通端口：firewall-cmd -zone=public -add-port=3344/tcp -permanent

重启防火墙：systemctl restart firewalld.service

bash 复制代码

[root@xhm ~]# docker exec -it b9dd398c741f  #进入nginx看看

root@b9dd398c741f:/# whereis nginx    #看nginx的配置在哪
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@b9dd398c741f:/# cd /etc/nginx  #可以进去瞅瞅
root@b9dd398c741f:/etc/nginx# ls
conf.d	fastcgi_params	mime.types  modules  nginx.conf  scgi_params  uwsgi_params
root@b9dd398c741f:/etc/nginx# 
root@b9dd398c741f:/etc/nginx# exit  #退出
[root@xhm ~]# docker stop b9dd398c741f   #停止

练习2：Docker安装tomcat#

1，下载tomcat

bash 复制代码

#官方使用
docker run -it --rm tomcat:9.0
#我们之前的启动都是后天，停止了容器之后还可以查到  docker run -it --rm 一般用来测试，用完就删

#我们还是正常使用
docker pull tomcat:9.0

2，启动运行 docker run -d -p 3355:8080 --name tomcat01 tomcat

运行之后，采用公网：3355访问，发现是404，且进入容器后，命令少了，没有webapps

原因：官方默认给的是最小镜像，删除了不必要的，保证最小可运行环境，webapp里面啥也没有

东西都在webapps.dist里面。所以可以尝试把webapps.dist的内容都复制给webapps，复制完之后，在用公网id:3355，即可访问成功

bash 复制代码

[root@xhm ~]# docker exec -it tomcat01 /bin/bash  #进入tomcat
root@d62a326806bd:/usr/local/tomcat# ls   #查看里面的内容
BUILDING.txt	 LICENSE  README.md	 RUNNING.txt  conf  logs	    temp     webapps.dist
CONTRIBUTING.md  NOTICE   RELEASE-NOTES  bin	      lib   native-jni-lib  webapps  work
root@d62a326806bd:/usr/local/tomcat# cd webapps
root@d62a326806bd:/usr/local/tomcat/webapps# cd ../webapps.dist
root@d62a326806bd:/usr/local/tomcat/webapps.dist# ls
ROOT  docs  examples  host-manager  manager
root@d62a326806bd:/usr/local/tomcat/webapps.dist# cd ..
root@d62a326806bd:/usr/local/tomcat# cp -r webapps.dist/* webapps  #复制
root@d62a326806bd:/usr/local/tomcat# cd webapps
root@d62a326806bd:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager
root@d62a326806bd:/usr/local/tomcat/webapps#

练习3：Docker部署ES+KIbana

(......)

16、作业三：部署ES+Kibana_哔哩哔哩_bilibili

Ⅵ，可视化

portainer

安装命令

bash 复制代码

docker run =d -p 8080:9000 \ --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

测试访问：http://公网ip:8088/#/init/admin

阿里云安全组打开外网8088端口

设置密码即创建用户进去

选择本地

Rancher

4，Docker镜像

I，理论理解

II，commit镜像

bash 复制代码

docker commit  提交一个容器成为一个新的副本

#命令和git原理类似  [TAG]版本
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名：[TAG]



#1,运行tomcat
docker run -it -p 8081:8080 tomcat #-it 交互模式启动  -p暴露端口

#2,查看运行的tomcat
docker ps

#3,进入容器
docker exec -it 容器id /bin/bash

#4,修改容器
docker cp -r webapps.dist/* webapps/   #-r递归拷贝所有

#5,测试
公网IP:8081


#5，提交修改的tomcat
docker commit -m="" -a="" 容器id mytomcat:1.0

修改容器：因为webapps是空，所以把webapps.dist里面的内容复制过来了

自己新建的镜像就提交好了

5，容器数据卷***

I，什么是容器数据卷

问题：如果数据都在容器内，删除容器之后，数据就会丢失；mysql容器如果删掉，数据全没了

需求：数据可以持久化；mysql数据可以存储到本地

解决：容器之间可以有一个数据共享技术！Docker容器中产生的额数据，同步到本地

即卷技术，目录挂载，将容器内的目录挂载到Linux上面

容器的持久化和同步操作，容器间也可以数据共享

挂载运行

bash 复制代码

docker run -it -v /home/xhm:/home/xhm centos

挂载成功的话 docker inspect 容器id可以看到如下信息

测试一边再linux上修改文件夹或者文件内容，查看容器内对应文件内容，会对应改变，反之亦然

II，实战：安装mysql

bash 复制代码

#拉取mysql镜像
docker pull mysql:5.7

#运行容器，需要做数据挂载， #安装启动mysql,需要配置密码
#官方测试：docker run -name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

#我们的测试启动
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器名字
docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mymysql mysql:5.7


#启动成功后，可以本地测试是否可连接   公网ip  root  123456 端口3310（映射容器内的3306）

#本地测试创建一个数据库，查看一下映射的路径内容是否改变

#删掉容器试试  
docker rm -r mymysql
#去查看挂载到本地的文件，依旧没有丢失

拉取镜像

运行启动，挂载配置文件，运行成功后。连接测试如图二

在sqlyog新增数据库，在容器内部会同步修改

删掉容器，查看主机内的挂载数据，仍然存在

III，具名挂载/匿名挂载

bash 复制代码

#匿名挂载
-v 容器内路径
#-P  随机映射端口   -v此处只写容器内地址
docker run -d -P --name nginx01 -v /etc/nignx nignx

#查看所有的volume的情况
docker volume ls
[root@xhm /]# docker volume ls
DRIVER    VOLUME NAME
local     9b948348fa86dc4d195c2774c9b0341bbe92a5754370584f4935ea4c53606e11
#这里这种就是匿名挂载，我们在-v 只写了容器内路径，没有写容器外路路径


#具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nignx

#查看
docker volume ls
[root@xhm /]# docker volume ls
DRIVER    VOLUME NAME
local     juming-nginx
#此处就是具名了

#通过 -v 卷名：容器内路径
#查看一下这个卷  juming-nginx只是一个名字不是目录，没有/
docker volume inspect juming-nginx
[root@xhm /]# docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2024-12-03T15:44:13+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]

docker的工作目录 /var/lib/docker/

所有的docker 容器内的卷，没有指定目录的情况下都是在 /var/lib/docker/volumes/xxxx/_data

通过具名挂载可以方便的找到我们的一个卷，大多数情况使用具名挂载

bash 复制代码

#区别具名挂载、匿名挂载、指定路径挂载
-v 容器内路径                 #匿名挂载
-v 卷名：容器内路径           #具名挂载
-v /宿主机路径：容器内路径     #指定路径挂载

拓展：

bash 复制代码

#通过  -v容器路径:ro  rw 改变读写权限
ro   readonly  # 只读
rw   readwrite   #可读可写

#一旦设置了容器权限，容器对我们挂载出来的内容就有限定了
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nignx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nignx

# ro  只要是这个权限，就说明这个路径只能通过宿主机来操作，容器内部无法操作

Ⅳ，初识dockerfile

dockerfilre就是用来构建docker镜像的构建文件，命令脚本

通过这个脚本可以生成镜像，镜像是一层一层的，脚本是一个一个的命令，每个命令都是一层

bash 复制代码

#1，先在/home下建一个文件夹吧（docker-test-volume），把后面所有的dockerfile文件都可放里面
mkdir docker-test-volume

#2，在docker-test-volume文件夹下新建一个文件dockerfile1
cd docker-test-volume
vim dockerfile1

#3,在dockerfile1里面添加脚本内容   命令  参数
FROM centos

VOLUME ["volume01","volume02"]    #匿名挂载

CMD echo "--------end-------"
CMD /bin/bash

#4,保存退出，查看一下文件内容是否写进
cat dockerfile1

#5，构建镜像
docker build -f /home/docker-test-volume/dockerfile1 -t xhm/centos:1.0 .

#6，查看镜像是否成功
docker images

在volume里面建一个文件

bash 复制代码

[root@4f61965bec21 /]# cd volume01
[root@4f61965bec21 volume01]# toucj catainrt.txt
bash: toucj: command not found
[root@4f61965bec21 volume01]# touch catainrt.txt
[root@4f61965bec21 volume01]# ld
ld: no input files
[root@4f61965bec21 volume01]# ls
catainrt.txt

查看挂载路径

bash 复制代码

[root@xhm /]# docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                                     NAMES
4f61965bec21   c59fb0f6837e   "/bin/bash"              5 minutes ago   Up 5 minutes                                             determined_hypatia
[root@xhm /]# docker inspect 4f61965bec21

查看挂载路径里面是否有文件

bash 复制代码

[root@xhm /]# cd /var/lib/docker/volumes/ec06cefe9b434ecac65b7c0469a9e488bb33ed9b1f0b98a88e5af538a83503bd/_data
[root@xhm _data]# ls
catainrt.txt
[root@xhm _data]#

以上方式常用，我们通常会构建自己的镜像

假设构建镜像的时候灭有挂载卷，要手动镜像挂载 -v 卷名：容器内路径

Ⅴ，数据卷容器

bash 复制代码

#1,开启容器01
docker run -it --name docker01 xhm/centos:1.0

#2，进入容器后不停止退出，查看运行容器
[root@7fb3409d49ce /][root@xhm /]# docker ps
CONTAINER ID   IMAGE            COMMAND                  CREATED         STATUS         PORTS     NAMES
7fb3409d49ce   xhm/centos:1.0   "/bin/sh -c /bin/bash"   2 minutes ago   Up 2 minutes             docker01


#3，开启容器2   使用--volumes-from
[root@xhm /]# docker run -it --name docker02 --volumes-from docker01 xhm/centos:1.0
[root@ec61cb27e463 /]# [root@xhm /]# docker ps
CONTAINER ID   IMAGE            COMMAND                  CREATED         STATUS         PORTS     NAMES
ec61cb27e463   xhm/centos:1.0   "/bin/sh -c /bin/bash"   8 seconds ago   Up 8 seconds             docker02
7fb3409d49ce   xhm/centos:1.0   "/bin/sh -c /bin/bash"   4 minutes ago   Up 4 minutes             docker01

#4,在容器1中的卷1添加文件
cd volume01
[root@7fb3409d49ce volume01]# touch docker01
[root@7fb3409d49ce volume01]# ls
docker01

#5，查看容器2中卷1 的文件
[root@ec61cb27e463 /]# cd volume01
[root@ec61cb27e463 volume01]# ls
docker01

他们的数据会同步修改
docker run -it --name docker02 --volumes-from docker01 xhm/centos:1.0
中的 --volumes-from 有点类似与类之间的额继承，son extent father
 --volumes-from 只要通过他我们就可以实现容器简单额数据共享

docker run -it --name docker02 --volumes-from docker01 xhm/centos:1.0
docker run -it --name docker03 --volumes-from docker01 xhm/centos:1.0
如果容器1 删掉的话，容器2，容器3的数据任然存在，即数据已经同步备份出去了，只要有一个容器还在使用此数据，数据就不会丢失

案例：

多个mysql实现数据共享

bash 复制代码

docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7

由此可实现两个容器的数据同步

结论：

容器之间配置信息的传递，容器数据卷的生命周期是一致持续到没有容器使用为止。

即所有用它的容器都停止了

但是一旦持久化到了本地，本地的数据是不会被删除的

6，DockerFile***

I，DockerFile介绍

dockerfile是用来构架docker镜像的文件！命令参数脚本

构建步骤：

1，编写一个dockerfile文件

2，docker build构建成为一个镜像

3，docker run运行镜像

4，docker push 发布镜像（DockerHup，阿里云镜像仓库）

很多官方的镜像都是基础包，很多功能没有，我们需要自己搭建

II，DockerFile构建过程

基础知识：

1，每个保留关键字（指令）都必须是大写字母

2，执行从上到下顺序执行

3，#代表注释

4，每个指令都会创建提交一个新的镜像层，并提交

构建过程：

dockerfile是面向开发的，我们以后要发布项目，做镜像，就要编写dockerfile文件

步骤：开发，部署，运维

DockerFile：构建文件，定义了一切步骤，源代码

DockerImages：通过DockerFile构建生成的镜像，最终发布和运行的产品

Docker容器：容器就是镜像运行起来提供服务的容器

III，DockerFile指令

bash 复制代码

FROM        # 基础镜像，一切从这里开始构建
MAINTAINER  # 镜像是谁写的  名字+邮箱
RUN         # 镜像构建的时候需要运行的命令
ADD         # 步骤：tomcat镜像，这个tomcat压缩包！添加内容
WORKDIR     # 镜像的工作目录
VOLUME      # 挂载的目录
EXPOST      # 暴露端口配置
CMD         # 指定这个端口启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT  # 指定这个端口启动的时候要运行的命令，可以追加命令
ONBUILD     # 当构建一个被继承的DockerFile 这个时候就会与运行ONBUILD的指令，触发指令
COPY        # 类似ADD 将我们的文件拷贝到镜像中
ENV         # 构建的时候设置环境变量

Ⅳ，实战测试：构建自己的centos

Docker Hub 99% 镜像都是从这个基础镜像过来的 FROM scratch，然后配置我们需要的软件和配置来构建的

bash 复制代码

#原本的centos 有些命令就没有
[root@xhm /]# docker run -it centos
[root@dc0c9a03c1f3 /]# pwd
/
[root@dc0c9a03c1f3 /]# vim
bash: vim: command not found
[root@dc0c9a03c1f3 /]# ipconfig
bash: ipconfig: command not found


#构建我们自己的centos
#1，先新建一个文件夹，专门存放dockerfile吧
[root@xhm /]# mkdir dockerfile
[root@xhm /]# ls
bin  boot  dev  dockerfile  etc  home  lib  lib64  media  mnt  opt  patch  proc  root  run  sbin  srv  sys  tmp  usr  var  www

#2，进入dockerfile文件夹创建一个自己的文件mydockerfile-centos
[root@xhm /]# cd dockerfile
[root@xhm dockerfile]# vim mydockerfile-centos

#3,写入对应的脚本内容
[root@xhm dockerfile]# cat mydockerfile-centos 
FROM centos

MAINTAINER xhm<418495356@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH     #配置工作目录，即进容器就会进这个目录

#因为我的是centos8，貌似已经没有维护了，此处需要换yum源
#所以会所加几个步骤
#1，进入仓库源文件夹
RUN cd /etc/yum.repos.d/    
#2，修改镜像配置
RUN sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
RUN sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
#3.清空原本的缓存
RUN yum clean all
#4. 重新生成缓存
RUN yum makecache
#5. 更新yum软件包
RUN yum update -y
#以上是我加的步骤

RUN yum -y install vim   #安装vim命令
RUN yum -y install net-tools

EXPOSE 80     #暴露端口

CMD echo $MYPATH
CMD echo "-------end------"
CMD /bin/bash

#4，构建dockerfile文件
docker build -f mydockerfile-centos -t mycentos:0.1 .

#5，查看镜像
[root@xhm dockerfile]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
mycentos              0.1       135ddde05271   7 minutes ago   630MB

#,进入镜像使用对应命令试试
#再测试之前没有的命令
#运行
[root@xhm dockerfile]# docker run -it 135ddde05271
#进入的工作地址就是我们在mydockerfile-centos里面设置的地址了
[root@ccfdc6557666 local]# pwd
/usr/local
#对应的命令也下载完，可以用了
[root@ccfdc6557666 local]# ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.18.0.3  netmask 255.255.0.0  broadcast 172.18.255.255
        ether 02:42:ac:12:00:03  txqueuelen 0  (Ethernet)
        RX packets 14  bytes 1235 (1.2 KiB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        inet6 ::1  prefixlen 128  scopeid 0x10<host>
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

[root@ccfdc6557666 local]# vim test

问题：

解决：

列出我们的镜像生成的步骤，变更历史

docker history 镜像id

Ⅴ，CMD/RNTRYPOINT区别

bash 复制代码

CMD         # 指定这个端口启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT  # 指定这个端口启动的时候要运行的命令，可以追加命令

对比俩dockerfile文件种的命令，先各自创建文件，内容一样，构建成镜像

构建完成运行，发现我们的ls -a的命令就生效了

如果我们需要追加参数-l 已形成ls -al 的命令，但结果如下

**cmd：**的情况下 -l直接替换了CMD["ls","-a"] 的命令，而 -l 不是命令，所以报错，如果需要执行得直接写成docker run 2b06f9641629 ls -al 去覆盖命令

**entrypoint：**得情况下，后面写 -l 则可以直接追加，而得到 ls -a -l 的效果

dockerfile种很多命令都十分相似，我们需要了解区别，测试效果

Ⅵ，实战测试：Tomcat镜像

1，准备镜像文件 tomcat压缩包，jdk压缩包

2，编写dockerfile文件，建议可使用官方命名 Dockerfile，这样在build的时候就不用-f 文件名了，可以默认直接启动

bash 复制代码

#Dockerfile文件
FROM centos
MAINTAINER xhm<428495356@qq.com>

COPY readme.txt /usr/local/readme.txt

ADD jdk-8u152-linux-x64.rpm /usr/local/
ADD apache-tomcat-9.0.96 /usr/local/

#1，进入仓库源文件夹
RUN cd /etc/yum.repos.d/    
#2，修改镜像配置
RUN sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*
RUN sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*
#3.清空原本的缓存
RUN yum clean all
#4. 重新生成缓存
RUN yum makecache
#5. 更新yum软件包
RUN yum update -y
RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_11
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.96
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.96
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.96/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.96/bin/logs/catalina.out

3，构建镜像

bash 复制代码

docker build -t diytomcat .

4，运行起来，并把对应目录挂载出去,外部发布也可以同步到容器内部目录

bash 复制代码

docker run -d -p 9090:8080 --name xhmtomcat -v /home/xhm/tomcat/test:/usr/local/apache-tomcat-9.0.96-windows-x64/webapps/test -v  /home/xhm/tomcat/tomcatlogs:/usr/local/apache-tomcat-9.0.96-windows-x64/logs diytomcat

5，卡bug了

30、实战：Dockerfile制作tomcat镜像_哔哩哔哩_bilibili

Ⅶ，发布镜像

发布镜像到阿里云

1，登录阿里云

2，找到容器镜像服务

3，创建命名空间

4，创建容器镜像

5，浏览阿里云参考此流程，进行发布

Ⅷ，docker小结图

7，Docker网络原理***

I，理解docker0

三个网络：如上图三个网卡分别是本机地址，阿里云内网地址，docker0地址

docker如何处理网络访问的？

bash 复制代码

先运行一个tomcat
[root@xhm ~]# # dpcker run -d -P --name tomcat01 tomcat

#查看容器内部网络地址 ip addr

[root@xhm ~]# docker exec -it tomcat01 ip addr
##以下是我遇到的问题###
报错：
[root@xhm ~]# docker exec -it tomcat01 ip addr
OCI runtime exec failed: exec failed: unable to start container process: exec: "ip": executable file not found in $PATH: unknown
原因：因为docker 容器是精简版的缺少一些命令
解决：
1.进去到容器：
docker exex -it [容器id]  bash
2.更新apt 
apt-get update
3 安装iproute2
apt install -y iproute2
4 安装完以后退出exit
ctrl+p+q
5 再次执行命令 不报错
###结束###################
[root@xhm ~]# docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
166: eth0@if167: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:12:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.18.0.2/16 brd 172.18.255.255 scope global eth0
       valid_lft forever preferred_lft forever


发现容器启动的时候会得到一个eth0@if166 ip地址，docker0分配的

linux是否可ping通容器内部？
测试：
[root@xhm ~]# ping 172.18.0.2
PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data.
64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.084 ms
64 bytes from 172.18.0.2: icmp_seq=2 ttl=64 time=0.063 ms
64 bytes from 172.18.0.2: icmp_seq=3 ttl=64 time=0.052 ms
64 bytes from 172.18.0.2: icmp_seq=4 ttl=64 time=0.075 ms
说明linux可以ping通docker容器内部

linux种容器跟容器之间是否可ping通？

原理

1，我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要安装了docker，就会有一个网卡docker0桥接模式，使用的技术是evth-pair技术

2，再次测试 ip addr 就多了一个网卡，即我们刚开了一个容器，匹配方式如图2

bash 复制代码

我们发现这个容器带来的网卡，都是一对一对的

这就是evth-pair技术，就是一对虚拟设备接口，他们都是承兑出现的，一端连着协议，一端彼此相连

正应为有此特性，evtn-pair充当一个桥梁，连接各种虚拟网络设备的

OpenStac，Docker容器之间的连接，OVS连接都是使用evth-pair技术

3，测试两个容器之间是否可以ping通，原理如何？

bash 复制代码

遇到的问题
[root@xhm ~]# docker exec -it tomcat01 ping 172.18.0.3
OCI runtime exec failed: exec failed: unable to start container process: exec: "ping": executable file not found in $PATH: unknown
解决 安装 ping：apt-get install -y iputils-ping
docker exec -it tomcat01 /bin/bash
apt-get install -y iputils-ping
ctrl+q+p退出

安完之后去ping就可以了
[root@xhm ~]# docker exec -it tomcat01 ping 172.18.0.3
PING 172.18.0.3 (172.18.0.3) 56(84) bytes of data.
64 bytes from 172.18.0.3: icmp_seq=1 ttl=64 time=0.136 ms
64 bytes from 172.18.0.3: icmp_seq=2 ttl=64 time=0.083 ms
64 bytes from 172.18.0.3: icmp_seq=3 ttl=64 time=0.096 ms

结论，容器之间可通信

网络模型图

结论：tomcat01和tomcat02是公用的一个路由器docker02

所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个默认的可用ip

docker使用的是linux的桥接,宿主机种是docker容器的网桥，docker0

docker种的所有网络接口都是虚拟的，虚拟的转发效率非常高（内网传递文件）

只要删除容器，对应的网桥一对就没有了

II，--link

bash 复制代码

场景：我们编写一个微服务，database url=ip:项目不重启，数据库ip换掉了，我们希望可以处理这个问题，可以明细来进行访问容器？


尝试直接名字之间ping 发现不可以
[root@xhm ~]# docker ps
CONTAINER ID   IMAGE     COMMAND             CREATED        STATUS        PORTS                                         NAMES
cd27f3ab6e5f   tomcat    "catalina.sh run"   22 hours ago   Up 22 hours   0.0.0.0:32769->8080/tcp, :::32769->8080/tcp   tomcat02
f5cf78512d33   tomcat    "catalina.sh run"   23 hours ago   Up 23 hours   0.0.0.0:32768->8080/tcp, :::32768->8080/tcp   tomcat01
[root@xhm ~]# docker exec -it tomcat02 ping tomcat01
ping: tomcat01: Name or service not known

加上--link
[root@xhm ~]# docker run -d -P --name tomcat03 --link tomcat02 tomcat
d4eafda72791c082f798d2a989bb6e88f68c6fc3a57a9d022b856661c2f24b33

再ping发现就可以直接用名字ping成功
[root@xhm ~]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.18.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.18.0.3): icmp_seq=1 ttl=64 time=0.152 ms
64 bytes from tomcat02 (172.18.0.3): icmp_seq=2 ttl=64 time=0.085 ms


 tomcat03 --link tomcat02 之后3可以ping  tomcat02,但反向不可ping通

bash 复制代码

[root@xhm ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
a8b8229274e4   bridge    bridge    local
2c9e6707c4c4   host      host      local
c0970bd9354a   none      null      local


docker network inspect a8b8229274e4

容器内部关系

docker inspect 03的id 能看到links内容

或者直接去看tomcat03的配置文件，可以看到他直接把02写进去了

本质：host映射 --link 就是再hosts配置中添加了一个172.18.0.3 tomcat02 cd27f3ab6e5f

III，自定义网络

我们常用自定义网络，而不是用docker0，docker0问题，他不支持容器名连接访问

容器互联：

bash 复制代码

查看所有的docker网络
[root@xhm ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
a8b8229274e4   bridge    bridge    local
2c9e6707c4c4   host      host      local
c0970bd9354a   none      null      local

网路模式：
bridge    桥接模式，在docker上搭桥 （默认）自己创建网络也用这种模式
host      主机模式，和宿主机共享网络
none      不配置网络， 
container  容器内网络联通（局限大。用的少）

测试，先删掉所有容器，还原成只有原来默认的3个网卡的样子

然后重新去启动一个

bash 复制代码

#我们直接启动的命令 --net bridge,而这个就是我们的docker0
#之前我们的启动方式如下，没有--net bridge 但这几个其实是默认会加的
 docker run -d -P --name tomcat01 tomcat
#我们可以写成这种
 docker run -d -P --name tomcat01 --net bridge tomcat

#docker0特点：默认，域名不能访问  --link可以打通连接

 #我们可以自定义网络
 #创建一个网络，名字叫mynet
 #--driver bridge   桥接
 #--subnet 192.168.0.0/16  子网地址  192.168.0.2    192.168.255.255
 #--getway 192.168.0.1   网关
docker network create --driver bridge --subnet 192.168.0.0/16 --getway 192.168.0.1 mynet

#创建成功后查看一下自己的网络
[root@xhm ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
4d3842d24d9d7b910f21af43b5b1fbf906bdb7623f544e5266cb3f210b3c724e
[root@xhm ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
a8b8229274e4   bridge    bridge    local
2c9e6707c4c4   host      host      local
4d3842d24d9d   mynet     bridge    local
c0970bd9354a   none      null      local
#查看自己的网络
[root@xhm ~]# docker network inspect mynet

bash 复制代码

#在我们自己创建的网络中开启俩，然后去查看
[root@xhm ~]# docker run -d -P --name tomcat-net --net mynet tomcat
52f085530e4b2d90f4ffee341ef9522a392a0eabaed9214848ff0e24184cab90
[root@xhm ~]# docker run -d -P --name tomcat-net02 --net mynet tomcat
c67553231ce268addf86dc7ad4963f9f765440eec85db81af18962347435d588
[root@xhm ~]# docker network inspect mynet      #如下，自己的网络就创建好了

bash 复制代码

不用--link也可以直接ping名字
[root@xhm ~]# docker exec -it tomcat-net ping tomcat-net02
PING tomcat-net02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.127 ms
64 bytes from tomcat-net02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.118 ms

我们自定义的网络docker都已经伴我们维护好了对用关系，

好处：
redis -不同的集群使用不同的网络，保证集群的安全和健康
mysql -不同的集群使用不同的网络，保证集群的安全和健康

Ⅳ，网络连通

如图，我们默认使用的都是docker0，我们自定义网络mynet后，我们用自己的额网络，那么想tomcat01 连接 tomca-net01的话，就是使用tomcat01去连mynet，命令如下

测试连接网络的方法

bash 复制代码

[root@xhm ~]# docker network connect mynet tomcat01
[root@xhm ~]# docker network inspect mynet

bash 复制代码

如上图所示，用mynet和tomcat01  connect后，
就直接把tomcat01加到了mynetw网络下
即一个容器两个ip地址
阿里云服务，公网ip，私网ip

正常下网卡跟网卡之间不能直接连，但容器和网卡可以直接打通


然后就去测试tomcat01是都跟mynet里面打通
[root@xhm ~]# docker exec -it tomcat-net ping tomcat01
PING tomcat01 (192.168.0.4) 56(84) bytes of data.
64 bytes from tomcat01.mynet (192.168.0.4): icmp_seq=1 ttl=64 time=0.140 ms
64 bytes from tomcat01.mynet (192.168.0.4): icmp_seq=2 ttl=64 time=0.092 ms

tomcat02没有连接，则无法ping通

[root@xhm ~]# docker exec -it tomcat-net ping tomcat02
ping: tomcat02: Name or service not known

结论：假设要跨网络操作别人，就需要使用docker network connect 连通

Ⅴ，实例：SpringBoot打包镜像

39、SpringBoot微服务打包Docker镜像_哔哩哔哩_bilibili

1，构建springboot项目

2，打包应用

3，编写dockerfile

4，构建镜像

5，发布运行

8，Docker Compose

9，Docker Swarm

10，CI\CD Jenkins

学习视频：【狂神说Java】Docker最新超详细版教程通俗易懂_哔哩哔哩_bilibilbiainxe