橘子学docker01之基本玩法

docker

docker镜像集成了最核心需要得环境，所以占空间小，运行快，启动秒级。

docker的几个概念：

注册中心：相当于超级码头，上面放的就是集装箱。

镜像（image）：集装箱,好比一个模板，可以通过这个模板来创建容器服务，tomcat镜像–》run–》tomcat01容器（提供·服务器），通过这个镜像可以创建多个容器，最终服务运行或者项目运行就是在容器中的。

**容器(container)：**运行起来的镜像，利用容器技术，独立运行一个或者一组应用，通过镜像来创建，启动，停止，删除等基本命令。

可以理解donker容器就是一个单独的Linux系统。

**仓库（repository）*仓库就是存放镜像的地方，仓库分为共有和私有，Docker Hub（默认是国外的），阿里云都有容器服务器，自己的。我们配置镜像加速就能用了，国外的太卡。

docker官网：https://www.docker.com/

docker的官方文档：https://docs.docker.com/，文档超级详细。

docker的仓库地址：https://hub.docker.com/

---

## docker和传统虚拟机技术的区别：
1、传统虚拟机是虚拟出一套硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件。
2、容器内的应用直接运行在宿主机的内核，容器自己没有内核，也不需要虚拟硬件，容器只包含自己那个运行的应用还有一些必须要有的函数库，至于内核就用宿主机的，提高了利用率，减少其他开销，变得更轻量级。
3、每个容器之间是互相隔离，每个容器都有属于自己的文件系统，互不影响。

Docker 的基本操作

安装Docker

环境准备：

1、linux基础   

2、Centos 7 

3、xshell连接

环境查看

# 系统内核时3.10以上的
[root@iZ2zec103hcivif4pv3ai2Z docker]# uname -r
3.10.0-1062.9.1.el7.x86_64

#系统版本是centos7
[root@iZ2zec103hcivif4pv3ai2Z docker]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"

安装docker

安装一切以官网文档为标准：https://docs.docker.com/engine/install/centos/

#1、卸载旧的版本：
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
                  
#2、安装Docker的依赖环境：
yum install -y yum-utils

#3、设置阿里的镜像仓库：
yum-config-manager  --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#更新yum软件包的索引
yum makecache fast

#4、安装docker:ce 表示社区版，ee表示企业版
yum install docker-ce docker-ce-cli containerd.io

#5、启动Docker服务：
systemctl start docker 

#6、使用docker version 测试是否安装

#7、设置为开机自动启动：
systemctl enable docker

#8、测试：
docker run hello-world
此时会拉取镜像，然后出现hello-world from docker就成功了。

#9、查看镜像是否下载下来
docker images

#10、卸载docker
卸载Docker Engine，CLI和Containerd软件包等docker依赖：
yum remove docker-ce docker-ce-cli containerd.io

删除环境，资源，包括主机上的映像，容器，卷或自定义配置文件不会自动删除。要删除所有图像，容器和卷：
rm -rf /var/lib/docker
rm -rf /var/lib/containerd
您必须手动删除所有之前已编辑的配置的相关文件。

还得配置阿里云加速器，我没有就不配了。可以去百度教程。

docker的底层原理

工作原理：守护进程…

为什么docker比vm快…

Docker的中央仓库

1、Docker官方的中央仓库：这个仓库是镜像最全的，但是下载速度慢

​ https://hub.docker.com/

2、国内的镜像网站：网易蜂巢，daoCloud…

​ https://c.163yun.com/hub#/home(需要登录)

​ http://hub.daocloud.io/(推荐使用)

3、在公司内部会采用私服的方式拉取镜像。需要添加以下配置。

** 需要在 /etc/docker/daemon.json(没有自己建) **

{

​ “registry-mirrors” : [“https://registry.docker.cn.com”],

​ “insecure-registries” : [“公司私服的ip:公司私服的端口号”]

}

重启两个服务

systemctl daemon-reload

systemctl restart docker

Docker的常用命令

帮助命令

docker version  	#显示docker的版本信息

docker info     	#显示docker的系统信息，包括镜像和容器的数量

docker [命令] --help  #帮助命令

帮助文档的地址：https://docs.docker.com/reference/

镜像命令

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

# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    bf756fb1ae65   14 months ago   13.3kB

# 解释一下
# REPOSITORY：镜像的仓库源，就是镜像的名字
# TAG：镜像的标签，版本号
# IMAGE ID：镜像的ID
# CREATED：镜像创建的时间
# SIZE：镜像的大小

# 可选项，参数
 -a, --all             # 列出所有的镜像
 -q, --quiet           # 只显示镜像的id
 -aq                   # 组合使用，查询所有的id,docker支持这种组合的参数，和linux一样

**docker search **:搜索指定的镜像

[root@iZ2zec103hcivif4pv3ai2Z docker]# docker search mysql   #列出所有的关于mysql的信息
NAME     DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql    MySQL is a widely used, open-source relation…   10585     [OK]       
mariadb  MariaDB Server is a high performing open sou…   3960      [OK]    

# 可选项，参数，通过docker search --help查看
例子：查出所有start是3000星级以上的
docker search mysql -f STARS=3000
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker search mysql -f STARS=3000
NAME      DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
mysql     MySQL is a widely used, open-source relation…   10585     [OK]       
mariadb   MariaDB Server is a high performing open sou…   3960      [OK]       

docker pull:下载镜像

#下载镜像 docker pull 镜像名[:tag]
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker pull mysql
Using default tag: latest  #如果不写tag，默认就是latest最新版本
latest: Pulling from library/mysql
a076a628af6f: Pull complete  #分层下载，docker镜像的核心机制，联合文件系统
f6c208f3f991: Pull complete  #把镜像文件分层，不同版本之间如果一样可以共享，共享的层就不用再次下载
88a9455a9165: Pull complete 
406c9b8427c6: Pull complete 
7c88599c0b25: Pull complete 
25b5c6debdaf: Pull complete 
43a5816f1617: Pull complete 
1a8c919e89bf: Pull complete 
9f3cf4bd1a07: Pull complete 
80539cea118d: Pull complete 
201b3cad54ce: Pull complete 
944ba37e1c06: Pull complete 
Digest: sha256:feada149cb8ff54eade1336da7c1d080c4a1c7ed82b5e320efb5beebed85ae8c #镜像签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest  #下载的真实地址

#因为真实地址的存在，所以上述下载就等价于
docker pull mysql
docker pull docker.io/library/mysql:latest

#指定版本下载，这个版本必须是dockerhub上存在的，不然下载不下来，因为就是去dockerhub下载的
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker pull mysql:5.7
5.7: Pulling from library/mysql
a076a628af6f: Already exists 
f6c208f3f991: Already exists 
88a9455a9165: Already exists 
406c9b8427c6: Already exists 
7c88599c0b25: Already exists 
25b5c6debdaf: Already exists 
43a5816f1617: Already exists 
1831ac1245f4: Pull complete 
37677b8c1f79: Pull complete 
27e4ac3b0f6e: Pull complete 
7227baa8c445: Pull complete 
Digest: sha256:b3d1eff023f698cd433695c9506171f0d08a8f92a0c8063c1a4d9db9a55808df
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

#检查一下
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
mysql         5.7       a70d36bc331a   6 weeks ago     449MB
mysql         latest    c8562eaf9d81   6 weeks ago     546MB
hello-world   latest    bf756fb1ae65   14 months ago   13.3kB

docker rmi -f 镜像Id :镜像的删除

docker rmi -f 容器id  #删除指定镜像Id
docker rmi -f 容器id1  容器id2  容器id3 ... #删除多个容器
docker rmi -f $(docker images -aq) #通过id删除全部镜像

那些指定id不用写全，能区分就行。

容器命令

说明：我们pull下载下来了镜像，就能运行起来成为容器，容器里面运行着服务，此处我们下载一个centos镜像来学习测试。

docker pull centos   #此时容器里运行的就相当于一个centos系统，这比虚拟机要快多了。

新建容器并启动

docker run [可选参数] 镜像id
#参数说明
--name="name    #容器名字，比如tomcat1 tomcat2用来给启动的容器取名字做区分
-d              #容器以后台方式运行
-it             #使用交互方式运行，进入容器内部查看内容
-P(大写p）       #指定容器的端口，        -P 8080：8080
	-P	ip:主机端口：容器端口
	-P  主机端口：容器端口（常用）
	-P 容器端口
	容器端口
-p(小写p）        #不显式端口，启动随机指定

#测试运行,启动并进入容器
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
centos       latest    300e315adb2f   3 months ago   209MB
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker run -it 300e315adb2f（也可以用容器名，启动进入） /bin/bash
[root@4b3cacb0c99e /]# ls  #我们已经看到进入了容器内部，是一个独立的centos的系统，小服务器，而且用户也变了，这个小系统是最基础版本的那些命令，有些命令还不全。
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv 

#从容器中退出主机
[root@4b3cacb0c99e /]# exit  #退出了容器内部，而且容器也结束运行了
exit

列出所有的运行中的容器

# docker ps [可选参数]：不加参数就是显示正在运行的容器
-a #列出当前正在运行的容器和以前历史运行过的容器
-n=?  #显示最近创建的?个容器记录
-q  #只显示容器的编号，当然可以组合使用
-aq   #显示所有的容器编号
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps -a
CONTAINER ID   IMAGE     COMMAND    CREATED         STATUS           PORTS     NAMES
4b3cacb0c99e   300e315adb2f   "/bin/bash"   6 minutes ago   Exited (0) 3 minutes ago             interesting_almeida
efcadb58f789   bf756fb1ae65   "/hello"      5 hours ago     Exited (0) 5 hours ago               amazing_margulis
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps -n=1
CONTAINER ID   IMAGE    COMMAND       CREATED         STATUS        PORTS     NAMES
4b3cacb0c99e   300e315adb2f   "/bin/bash"   8 minutes ago   Exited (0) 5 minutes ago             interesting_almeida
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps -q
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps -aq
4b3cacb0c99e
efcadb58f789

退出容器

exit    #直接容器停止并且退出
ctrl  + p + q   #容器退出但是不停止运行

删除容器

docker rm 容器id  #删除指定的容器，不能删除正在运行的容器，如果要强制删除要用docker rm -f 容器id
docker rm -f $(docker ps -aq)   #删除所有的容器
docker ps -a -q|xargs  docker rm #删除所有的容器

启动和停止容器

#第一次运行之后，查询历史运行就有容器id了，就可以直接跑了，不用再run镜像了
docker start 容器id   #启动容器
docker restart 容器id #重启容器
docker stop 容器id    #停止容器
docker kill 容器id    #强制停止当前容器

其他命令

后台启动容器：-d

# docker run -d 镜像名  
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker run -d centos
7f4d2563b9d6a3995a0ec97889b2aec8c79057ffa740b953f740062395b97024
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

#常见问题，启动后docker ps发现容器centos停止了

#坑：docker容器使用后台运行，就必须要有一个前台进程，docker要是发现没有前台应用就会自动停止，所以你以前-it -/bin/bash就相当于一个前台的连接进去容器，所以它不停。
#nginx，容器启动后，发现自己没提供服务，就会立即停止，其实就是没有程序了。

查看容器日志

docker logs -tf --tail 显示条数 ：发现没有日志

#自己往容器里写一段脚本
#docker run -d centos /bin/sh -c "while true:do echo lwqniubi;sleep 1;done"

[root@iZ2zec103hcivif4pv3ai2Z docker]# docker run -d centos /bin/sh -c "while true;do echo lwqniubi;sleep 1;done"
6f0bd66bbe90d7541c7a2beda5ef17970505bb70e6b1a430e46a52f30439b45f
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS        PORTS     NAMES
6f0bd66bbe90   centos    "/bin/sh -c 'while t…"   2 seconds ago   Up 1 second             gallant_brown
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker logs -f -t 6f0bd66bbe90

#显示日志
-tf   #显示日志，-t -f可以组合用
--tail  number #显示number条日志
 docker logs -f -t  --tail 10 6f0bd66bbe90 #显示最近10条日志

查看容器中的进程信息，类似于linux的ps

# docker top 容器id
docker top 6f0bd66bbe90
以后可以进去容器杀个进程什么的，比如杀个容器里的tomcat之类的，因为以后自己打包一个容器里可能多个服务。

查看镜像的元数据

#命令：
docker inspect 容器id
查看容器的一些基本系统级别数据。

进入当前正在运行的容器

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

#方式一
docker exec -it 容器id  bashshell
exit退出容器。
#测试
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE     COMMAND      CREATED          STATUS          PORTS     NAMES
6f0bd66bbe90  centos  "/bin/sh -c 'while t…"   11 minutes ago   Up 11 minutes             
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker exec -it 6f0bd66bbe90 /bin/bash
[root@6f0bd66bbe90 /]# ls  #进入了
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv 
[root@6f0bd66bbe90 /]# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 14:33 ?     00:00:00 /bin/sh -c while true;do echo lwqniubi;sleep 1;done
root       748     0  0 14:45 pts/0    00:00:00 /bin/bash
root       821     1  0 14:46 ?        00:00:00 /usr/bin/coreutils --coreutils-prog-
root       822   748  0 14:46 pts/0    00:00:00 ps -ef

#方式二
docker attach 容器id
#测试
docker attach  6f0bd66bbe90
看到正在运行的程序


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

从容器内部拷贝文件到外部主机上

#命令，不管你容器是不是启动着，只要里面有对应文件就能复制，你创建了又停了只要没删就是有。
docker  cp 容器id:容器内路径  主机目的路径

#测试
#查看当前主机，没有文件
[root@iZ2zec103hcivif4pv3ai2Z docker]# ls  
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE     COMMAND        CREATED     STATUS          PORTS     NAMES
6f0bd66bbe90   centos    "/bin/sh -c 'while t…"   26 minutes ago   Up 26 minutes

#进入容器内部在opt下创建一个文件test.java
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker exec -it 6f0bd66bbe90 /bin/bash
[root@6f0bd66bbe90 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv 
[root@6f0bd66bbe90 /]# cd opt
[root@6f0bd66bbe90 opt]# touch test.java
[root@6f0bd66bbe90 opt]# ls
test.java

#把容器内得test.java文件复制到外部主机得opt里
[root@iZ2zec103hcivif4pv3ai2Z docker]# ls /opt
test.java

#拷贝是一个手动过程，未来使用数据卷-v实现容器内外得同步。

练习

Docker部署Nginx

# 1、搜索nginx的镜像信息
docker search nginx
# 2、根据信息下载对应版本nginx（我这里就用默认最新）
docker pull nginx
# 3、查看下载镜像
docker images
# 4、启动nginx容器
docker run -d --name nginx01 -p 8180:80 f6d0b4767a6c
	#解释一下：
	-d:表示后台启动
	--name nginx01：启动了一个容器，名字为nginx01,你可以随意命名，就能启动多个。
	-p:表示端口
	8180:80  :nginx的默认端口是80，我们这个nginx是部署在docker容器里的，容器是和外面隔离的，而你访问只是去访问你得linux宿主机，隔离的你访问不到，所以就需要映射端口，我把容器里nginx默认的80端口和宿主机linux的8180做映射，以后我就访问Linux的8180就能映射到容器里的80了。
	f6d0b4767a6c:镜像id，表示使用该镜像创建容器


# 5、测试访问
curl localhost:8180

# 6、进入nginx容器内部
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                    NAMES
d54b129e940b   f6d0b4767a6c   "/docker-entrypoint.…"   17 minutes ago   Up 17 minutes   0.0.0.0:8180->80/tcp     nginx01

[root@iZ2zec103hcivif4pv3ai2Z docker]#  docker exec -it d54b129e940b bin/bash #进入容器

root@d54b129e940b:/usr/local/src# whereis nginx   #查看安装位置
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@d54b129e940b:/usr/local/src# cd /etc/nginx
root@d54b129e940b:/etc/nginx# ls
conf.d	fastcgi_params	koi-utf  koi-win  mime.types  modules  nginx.conf  scgi_params	uwsgi_params  win-utf
root@d54b129e940b:/etc/nginx# cat nginx.conf
# 6、页面访问

思考：我们每次改动nginx配置文件，都需要进入容器内部，十分的麻烦，要是能在容器外部提供一个映射路径，达到每次在外部修改使得容器内部iu能自动修改多好。这就是-v 数据卷技术。

Docker部署Tomcat

#官方的使用：
docker run -it --rm tomcat:9.0   #一般用来测试，--rm是用完就删了，所以我们一般不用，它运行一次就没了。

#我们之前的启动都是后台启动，停止了容器后容器还能查到，--rm是用完就删，一般用来测试。

#常用的是下载启动
docker pull tomcat  #不指定版本号默认就是最新的

#启动运行
docker run -d -p 8080:8080 --name tomcat01  tomcat

#启动成功但是页面访问404，因为最新的镜像容器内部webapp是空的，而tomcat得默认网站就在webapp下
#进入容器
docker exec -it  tomcat01 /bin/bash

#进入发现，1、linux命令有的不能用，因为它极尽简化 2、没有webapps，是因为阿里云镜像得原因，默认是最小镜像，所有不必要得全部删除了，方便下载。只保证了最小得客运行环境。
#把webapps.dist(这里面是个基本得备份)里得复制到webapp下，就可以了。
cp webapps.dist/*  webapps

思考：我们以后部署项目，如果每次都要进入容器就十分得麻烦，要是能在容器外面提供一个路径，webapps我们就直接在外部布置项目，自动同步到容器内部就好了。

Docker部署ES+kIbana

#es比起其他暴露得端口比较多，9200，9300
#es十分得耗费内存
#es得数据一般需要放置到安全目录，需要数据卷挂载
# --net somenetwork?需要涉及网络配置

#启动elasticsearch,直接启动，它发现没镜像就会自己先拉取镜像。
docker run -d --name elasticsearch01  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

#启动之后发现linux卡死了，使用docker stats查看docker占用cpu状态，占比十分大。

#es是十分耗费内存得

#查看docker stats，发现占比巨大
[root@iZ2zec103hcivif4pv3ai2Z ~]# docker stats

CONTAINER ID   NAME              CPU %     MEM USAGE / LIMIT     MEM %     NET I/O           BLOCK I/O        PIDS
f5801a042824   elasticsearch01   0.00%     360.2MiB / 1.795GiB   19.60%    0B / 0B           6.44MB / 729kB   42
d54b129e940b   nginx01           0.00%     1.953MiB / 1.795GiB   0.11%     5.18kB / 5.81kB   0B / 4.1kB       3
3be601876cef   tomcat01          0.08%     127.6MiB / 1.795GiB   6.94%     52.2kB / 392kB    10.1MB / 0B      31
6f0bd66bbe90   gallant_brown     0.01%     3.652MiB / 1.795GiB   0.20%     2.4kB / 0B        6.77MB / 0B      4

#测试一下启动成功了
[root@iZ2zec103hcivif4pv3ai2Z ~]# curl localhost:9200
{
  "name" : "f5801a042824",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "NuEcsBc9SbuUgEnGKXqsvQ",
  "version" : {
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

#赶紧关闭，在启动时增加内存限制，修改配置文件，-e增加环境配置参数，设置常规使用64m，最大分配512m
docker run -d --name elasticsearch01  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node"  -e ES_JAVA_OPTS="-Xms64m  -Xmx512m"  elasticsearch:7.6.2
这次就不卡了。

使用kibana连接es直接连不上，因为容器互相隔离，但是es得端口已经和宿主机Linux做了对应，所以可以把宿主机当成中间传递。

可视化

1、portainer(先用这个，不是最终的)

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

2、Rancher(CI/CD再用)

什么是portainer?

Docker图形化界面管理工具，提供一个后台面板供我们使用操作。

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

访问测试：http:ip:8088/

…这个不重要，后面补上，我没测试过。

Docker镜像讲解

镜像是什么

镜像是一种轻量级，可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码，运行时，库，环境变量和配置文件。

所有的应用，直接打包docker镜像就可以直接运行跑起来。

如何得到镜像

1、从远程库下载。

2、朋友拷贝给你。

3、自己制作一个镜像，DockerFile.

Docker镜像加载原理

UnionFS(联合文件系统)

我们下载的时候看到的一层一层就是这个。具体可以百度。

特性：一次同时加载多个文件系统，但从外面看起来只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。

就是不同的容器或者相同的容器，相同的层可以共用，mysql用了那个，下次tomcat下载要是还用就能复用，不需要再下载了，节省。

分层理解

commit镜像

docker commit  # 提交现容器成为一个新得镜像

# 命令和git很像
docker commit  -m="提交的描述信息"  -a="作者" 容器id 目标镜像名:[tag版本号]

实战测试：

# 1、启动一个默认的tomcat

# 2、发现这个默认的tomcat是没有webapps应用，镜像的原因，阿里云官方默认webapps下没有这些文件，它只保留了必须启动的一些东西。

# 3、我自己拷贝进去那些文件进入webapps中

# 4、此时我们这个容器就比默认的多了，将我们操作过的容器通过commit提交为一个镜像，我们以后就用我们修改过的镜像即可，这就是我们自己修改创建的一个新镜像。
[root@iZ2zec103hcivif4pv3ai2Z ~]# docker commit  -m="lwq add wabapps" -a="lwq" 3be601876cef tomcat02:1.0
sha256:04a183e0cb0f926d167454c00bf283049e28a1006fd74bc8ce80a91f7fa8dc04
[root@iZ2zec103hcivif4pv3ai2Z ~]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
tomcat02              1.0       04a183e0cb0f   5 seconds ago   654MB
tomcat                latest    040bdb29ab37   7 weeks ago     649MB
nginx                 latest    f6d0b4767a6c   8 weeks ago     133MB
centos                latest    300e315adb2f   3 months ago    209MB
portainer/portainer   latest    62771b0b9b09   7 months ago    79.1MB
elasticsearch         7.6.2     f29a1ee41030   11 months ago   791MB

到此处docker算是入门了，此时我们对分层有理解了，我创建的tomcat02和01大部分都是共用层的，多的就是自己添加的那些。

镜像的操作（补充）

# 1、从仓库拉取镜像到本地
docker pull 镜像名称[:tag]   # []表示可以不写，如果不写版本号就是默认最新版本

# 举个栗子：
docker  pull  daocloud.io/library/tomcat:8.5.14-jre8
#daocloud.io/library/tomcat:8.5.14-jre8是从daocloud上找下来的

---

# 2、查看本地全部docker镜像
docker images
[root@iZ2zeanc2b2vggedkulxdnZ ~]# docker images
REPOSITORY                   TAG           IMAGE ID       CREATED         SIZE
hello-world                  latest        bf756fb1ae65   13 months ago   13.3kB
daocloud.io/library/tomcat   8.5.14-jre8   a0fd548664d9   3 years ago     367MB

---

# 3、删除本地镜像
docker rmi 镜像的标识号（不用写全，只要能保证是它就行）

---

# 4、镜像的导入导出（不规范）
#就是将本地的镜像文件打包，然后可以拷走，直接在其他地方再导出就是你打包的那个东西了

# 将本地的镜像导出
docker save -o 导出的路径/导出的名字(image为后缀)  要导出镜像的id
#docker save -o /opt/docker/tomcat.image  a0fd548664d9

#加载本地的镜像文件（相当于解压你导出的文件，就能用了，和上面的相对的）
docker load -i 加载的镜像名称
#docker load -i tomcat.image
[root@iZ2zeanc2b2vggedkulxdnZ docker]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    bf756fb1ae65   13 months ago   13.3kB
<none>        <none>    a0fd548664d9   3 years ago     367MB

#上面加载完的镜像是没有名字版本号的,是none，所以要修改以下镜像文件
docker tag  镜像id（不必全） 镜像名字:版本号（名字自己取，版本号实事求是就行）
[root@iZ2zeanc2b2vggedkulxdnZ docker]# docker tag   a0fd548664d9 tomcat:8.5
[root@iZ2zeanc2b2vggedkulxdnZ docker]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
hello-world   latest    bf756fb1ae65   13 months ago   13.3kB
tomcat        8.5       a0fd548664d9   3 years ago     367MB

容器的操作（补充）

# 1、运行容器
#简单的操作就是：
docker  run  镜像的标识|镜像的名称[:tag]

#规范的操作，常用的参数
docker  run -d -p 宿主机端口：容器端口  --name 容器名称 镜像的标识|镜像名称[:tag]

# -d：代表后台运行该容器，不至于关了窗口容器也没了
# -p 宿主机端口：容器端口：为了映射当前linux端口和容器的端口，你客户端访问的是Linux的，所以要映射进去docker内部才能真正访问docker提供的服务。
# --name容器名称：你运行容器的名字，自己取就好，真正确定运行哪个容器是后面的标识。

#docker run -d -p 8080:8080  --name tomcat  b4b762737ed4

---

# 2、查看正在运行的容器
docker ps [-qa]
# -a:查看全部的容器，包括没有运行的
# -q:只查看容器的标识
# -qa：只查看正在运行的容器标识

---

# 3、查看容器的日志（启动，运行）
docker logs -f 容器id
# -f:可以滚动的查看日志的最后几行，退出用ctrl + c

---

# 4、进入容器内部做操作
docker exec -it 容器id bash
#一般不建议进入容器内部操作，有时候需要确认文件在哪可以进去
exit退出

---

#5、删除容器（删除容器前，需要先停止容器）
docker stop 容器id #停止某一个容器
docker stop $(docker ps -qa) #停止所有运行的容器

docker rm 容器id #删除某一个容器
docker rm $(docker ps -qa) #删除所有运行的容器

---

# 6、启动容器
docker start 容器id（第一次运行完，本地就有容器环境了，下次就能启动了）

Docker的容器数据卷

什么是容器数据卷

docker的理念回顾

docker是将应用和环境打包成一个镜像，就能很方便的带着环境直接运行整个应用。

数据都放在容器中有两个问题：

1、如果将容器删除，数据就会丢失，所以需要将数据持久化。

2、每次修改什么文件都要进入容器中修改，极其不便。

所以需要一个技术，将容器数据和本地同步，再本地修改可以直接反应到容器中，在容器内部产生的数据也能同步到本地。这就是数据卷技术，目录的挂载，将我们容器内的目录，挂载到linux上面。

---

总结起来一句话，容器的持久化和同步操作，容器间也可以共享数据，挂载一个数据卷地址就可以了。

使用数据卷

方式一：直接使用命令挂载 -v

docker run -it -v 主机目录:容器内目录  

# 测试
docker run -it -v /home/ceshi:/home  centos /bin/bash

#启动之后，我们可以使用docker inspect 容器id来查看挂载情况
docker inspect 8a5737fcf86a

测试文件同步：

再来测试：

1、停止容器

2、宿主机修改文件内容

3、启动容器

4、容器内的数据也被同步，可见是宿主机和容器的双向同步。

所以以后修改容器内部就直接在宿主机上修改，容器内部就能自动同步了。

实战：安装Mysql

思考：mysql数据的持久化。

# 拉取mysql镜像
[root@iZ2zec103hcivif4pv3ai2Z ~]# docker pull mysql:5.7

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

# 启动我们的容器
docker run -d -p 8088:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 a70d36bc331a

#解释：
-d:后台运行
-p:端口映射
-v：数据卷挂载，本地路径映射到容器路径
-e：环境配置
--name:定义容器名字

#启动之后，用navicat连接一下ip和8080端口

#navicat连接对应linux的服务器地址，端口为宿主机的8088端口，8088映射容器3306就连接上了。

#在navicat创建了一个数据库test，进去容器的/var/lib/mysql发现有这个表，在宿主机上的/home/mysql/data也有，可见映射同步成功，之后你只要映射了，对应的文件外面修改了容器内部也就修改了。

#你把容器删除了，外面宿主机的数据也不会丢失这就是持久化成功了。


docker create --name mysql-master01 -v /data/mysql/master01/data:/var/lib/mysql -v /data/mysql/master01/conf:/etc/mysql/conf.d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root mysql:5.7.33

docker create --name mysql-slave1 -v /data/mysql/slave01/data:/var/lib/mysql -v /data/mysql/slave01/conf:/etc/mysql/conf.d -p 3307:3306 -e MYSQL_ROOT_PASSWORD=root mysql:5.7.33

具名和匿名挂载

# 匿名挂载
# 命令
-v 容器内部路径
# 测试，挂载一个nginx，直接就-v 后面是容器内部的路径
docker run -d -P(大写的随机指定端口，我这里测试就随机了) --name nginx01 -v /etc/nginx  nginx

# 查看所有的volume的情况
[root@iZ2zec103hcivif4pv3ai2Z /]# docker volume ls
DRIVER    VOLUME NAME
local     0bd9502f2a7328e3ef0db380f31981d37ab7ab712dab257b4f0d57a878a0e0b8
# 这里发现，这种就是匿名挂载，我们在-v后面只写了容器内部的路径，没写容器外部的路径。查出来的volume就是一长串字符串这个名字，没具体名字。

#具名挂载
[root@iZ2zec103hcivif4pv3ai2Z /]# docker run -d -P --name nginx02  -v juming-nginx:/etc/nginx nginx
b5ec3d3915d8201c9fe62c3021be808a57c4c4d6bf0adb28c2781c7341fa25ee
# 说明：
-v 后面直接就是一个数据卷名字：容器内路径 这里和上面挂载mysql不一样，这个：前面不是外部路径，是名字，因为路径前面都有/现在没有就是名字。
# 查看数据卷
[root@iZ2zec103hcivif4pv3ai2Z /]# docker volume ls
DRIVER    VOLUME NAME
local     juming-nginx

# 通过 -v 卷名：容器内部路径，查看一下这个卷
# inspect查看数据卷

所有的docker容器的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/***/_data
我们通过具名挂载可以方便的找到我们的一个卷，大多数都是具名挂载。

# 如何区分是具名挂载还是匿名挂载还是指定路径挂载
-v 容器内路径      # 匿名挂载
-v 卷名:容器内路径  # 具名挂载
-v /宿主机路径:容器内路径 # 指定路径挂载

拓展：

# 通过 -v 容器内路径:ro 或者rw 设置读写权限
ro readonly # 只读
rw readdwrite  # 可读可写

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

# ro是只读，针对的是说容器只读，只要看到这个就说明这个路径是只能对宿主机操作的，容器内部是无法修改的。

初识Dockerfile

Dockerfile就是用来构建docker镜像的文件，其实就是一个脚本，用来创建docker镜像的。

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

# 创建一个dockerfile文件（脚本文件,命令全部大写）,文件名字可以随意，但是建议就叫Dockerfile
# 文件中的内容格式为：指令（大写） 参数
FROM centos     #表示镜像是以现有的一个叫centos镜像为基础层的
VOLUME ["volume01","volume02"]   #在基础层上添加两个数据卷，vo1和vo2，都是以匿名挂载的形式，在生成镜像的时候就直接指定容器内路径。
CMD echo "---------end--------"   #在容器输出一句话
CMD /bin/bash   # 使用bin bash进入容器，就是生成镜像的时候，我们是进去的

#以上没一句命令都是在基础centos的基础上加了一层，docker镜像就是一层一层的

使用镜像文件生成一个镜像:docker build -f /opt/docker-test-volume/Dockerfile -t lwq-centos:1.0 .

[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# pwd
/opt/docker-test-volume
[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# vim Dockerfile
[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# ls
Dockerfile
[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# cat Dockerfile 
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "---------------------------end-----------------"
CMD /bin/bash
[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# docker build -f /opt/docker-test-volume/Dockerfile  -t lwq-centos:1.0 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos   #第一句执行，第一层构建
 ---> 300e315adb2f
Step 2/4 : VOLUME ["volume01","volume02"] #第二句执行，第二层构建
 ---> Running in 42ece5a6a1da 
Removing intermediate container 42ece5a6a1da
 ---> 1c4d223008df
Step 3/4 : CMD echo "---------------------------end-----------------"  #第三句执行，第三层构建
 ---> Running in dd956b2fe0e7
Removing intermediate container dd956b2fe0e7
 ---> c64818729098
Step 4/4 : CMD /bin/bash    #第四句执行，第四层构建
 ---> Running in f878d7c6cc0f
Removing intermediate container f878d7c6cc0f
 ---> 5a6fba29f440
Successfully built 5a6fba29f440
Successfully tagged lwq-centos:1.0


#解释一下
docker build -f /opt/docker-test-volume/Dockerfile  -t lwq-centos:1.0 .
build:构建参数
-f:表示使用文件构建
/opt/docker-test-volume/Dockerfile  ：指定是哪个文件
-t：target表示目标镜像
lwq-centos:1.0  ：目标镜像名
.  ：表示在当前路径下执行，所以那个指定文件可以直接写，不用写绝对路径，因为是当前路径。

启动我们创建的镜像

[root@iZ2zec103hcivif4pv3ai2Z docker-test-volume]# docker run -it lwq-centos:1.0  /bin/bash
[root@e94dc4ed1d75 /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var  volume01	volume02

#启动成功，我们发现内部也有volume01	volume02这两个路径。
#注意，你直接启动不加版本号，它默认去找lasted，没有这个版本，所以记得加上1.0 ，我们创建的时候指定的1.0

查看容器挂载情况 e94dc4ed1d75是容器id

[root@iZ2zec103hcivif4pv3ai2Z ~]# docker inspect e94dc4ed1d75

测试一下是不是内部外部同步了

# 在容器内部路径创建一个文件

这种方式使用的特别多，因为我们通常会自己构建镜像。假设构建镜像的时候没有挂载卷，就要手动挂载-v 卷名：容器内路径。

数据卷容器（–volumes-from）

多个容器之间做数据的同步，多个Mysql同步数据。

就是centos2这个容器同步了centos1这个容器，那么以后1，2之间数据就是双向同步的，删除了一个另一个不会受影响，可以当成一个数据备份。

启动两个容器，设置同步。

在docker01的volume01数据卷中创建一个文件，看看docker02容器里有没有。

# 你创建了docker03继承于docker01三个之间就是全部同步了，你删除docker01，查看docker02,docker03里还能看到文件，就是说删除一个不会影响其他的运行，直到全部删除完了才行。是一个互相拷贝的概念，带点复制备份。

多个mysql之间是可以实现数据共享。

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

docker run -d -p 8088:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql02
--volumes-from mysql01 mysql:5.7

#这个时候可以实现两个容器的数据同步。

结论：

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

但是一旦持久化到本地，这个时候，本地的数据不会因为删除哪个容器而被删除。

DockerFile

DockerFile介绍

dockerfile是用来构建docker镜像的文件，是一个命令参数脚本。

构建步骤：

1、编写一个dockerfile文件

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

3、docker run运行镜像

4、docker push 发布镜像（可以发布到DockerHub、阿里云镜像仓库上）

你去官方查看镜像点进去都是在github上的一个个的dockerfile文件，但是很多官方镜像都是基础包，只保留了运行必须的一些数据信息，很多功能都没有，所以我们一般会创建自己的镜像文件。

官方可以制作镜像，我们也可以。

DockerFile构建过程

基础知识

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

2、执行指令从上到下。

3、# 表示注释。

4、每个执行都会创建提交一个新的镜像层，并提交。

dockerfile是面向开发的，我们以后要发布项目做镜像，就需要编写dockerfile文件，这个文件十分简单。

Docker镜像逐渐成为企业交付的标准，需要掌握拿下。

步骤：开发，部署，运维。

DockerFile：构建一个镜像生成的一切步骤。

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

Docker容器：容器就是镜像运行起来提供服务的。以前我们项目打包为jar或者war，现在只需要把项目弄成镜像，包含一切组件，直接运行发布就行。

DcokerFile的指令

以前我们就是使用别人的镜像，现在有了这些指令，我们就能自己创建自己的镜像文件。

FROM      			# 基础镜像，一切都是从这一层开始加，一切从此开始构建
MAINTAINER			# 镜像是谁写的，姓名+邮箱（国际惯例）
RUN					# 镜像构建的时候需要运行的命令，run后面跟你要执行的命令
ADD					# 添加文件进入镜像，比如，把tomcat镜像添加集成到你制作的镜像中，添加tomcat一层，搭建一个里面有tomcat的容器，不然它里面的项目要起tomcat起谁去呢？
WORKDIR				# 镜像当前的工作目录，exec进入的目录
VOLUME				# 数据卷的挂载目录
EXPOSE				# 保留端口配置，对外指定端口，这里直接在镜像暴露端口，这里不暴露，启动的时候-p暴露才行
CMD					# 指定这个容器启动的时候要运行的命令，只有最后一个会生效，后面的替代前面的
ENTRYPOINT          # 指定这个容器启动的时候要运行的命令，比起CMD不会替代，会追加指令
ONBUILD				# 当构建一个被继承的DockerFile这个时候就会运行ONBUILD的指令，触发指令
COPY 				# 类似ADD，将我们的文件拷贝到你要制作的镜像中
ENV					# 构建的时候设置环境变量，和run的时候那个-e差不多

实战测试1

Docker Hub中99%的镜像是从这个基础镜像过来的 FROM scratch，然后配置需要的软件和配置来进行添加构建。

我们从dockerhub上下下来的ccentos容器里有很多命令是没有的，他是个阉割版的。

所以我们现在以centos为例，我们制作一个有这两个命令的加强版的镜像。

创建一个自己的centos,加强版的

# 1、编写dockerfile文件
FROM centos     # 从我本地下载的镜像centos作为基本的版本层开始制作
MAINTAINER   lwq<2018305346@qq.com>   # 作者信息

ENV  MYPATH  /usr/local   # 声明一个环境变量，路径作为一个变量，可以多个
WORKDIR  $MYPATH   # 把这个路径变量设置给工作目录

RUN yum -y install  vim    # 制作过程需要执行的命令，下载vim指令
RUN yum -y install net-tools  # 下载一些网络的指令，ifconfig就在这里面

EXPOSE  80   #暴露端口

CMD echo $MYPATH   # 制作过程输出这个路径变量
CMD echo "----------------------------end-----------------"   # 输出一句话
CMD /bin/bash   # 执行进入/bin/bash

# 2、通过编写的dockerfile创建镜像
# 命令 docker build -f dockerfile文件路径 -t 镜像名:[tag版本号] .
docker build -f myCentosDockerFile -t lwqcentos:1.0 .

成功：
我们看到日志，生成的过程就是一层一层的创建，各种过程，这里就不列出来了。
Successfully built 6aea258a4627
Successfully tagged lwqcentos:1.0

# 3、测试运行
docker run -d -it lwqcentos /bin/bash

# 4、可以通过docker history查看镜像的制作过程，历史记录，变更历史
docker history 镜像id

# 我们平时拿到一个镜像就能看看它的制作过程记录

CMD和ENTRYPOINT的区别

CMD					# 指定这个容器启动的时候要运行的命令，只有最后一个会生效，后面的替代前面的
ENTRYPOINT          # 指定这个容器启动的时候要运行的命令，比起CMD不会替代，会追加指令

测试CMD命令：

# 1、编写dockerfile文件
[root@iZ2zec103hcivif4pv3ai2Z docker]# vim dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]   # ls 和-a是命令和参数，放到两个“”里，各是各的

# 2、通过镜像文件，构建镜像
[root docker]# docker build -f dockerfile-cmd-test -t cmdtest .
Sending build context to Docker daemon  3.072kB
Step 1/2 : FROM centos
 ---> 300e315adb2f
Step 2/2 : CMD ["ls","-a"]
 ---> Running in 9f561f311c7c
Removing intermediate container 9f561f311c7c
 ---> 086ef3732fde
Successfully built 086ef3732fde
Successfully tagged cmdtest:latest

# 3、run运行镜像，记住CMD命令是在运行的时候生效的，发现我们的ls -a命令生效了，
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker run 086ef3732fde
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt

# 4、命令每次启动都能在启动时候加进去，这种只能生效一次，不像那种CMD写进文件里制作的，我们来加一个
# 追加一个命令-l 我们文件里写的ls -a这里加一个-l最终应该是ls -al
[root@iZ2zec103hcivif4pv3ai2Z docker]# docker run 086ef3732fde -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:370: starting container process caused: exec: "-l": executable file not found in $PATH: unknown.
# 我们看到报错了，因为CMD这种命令它是覆盖，最后的-l会覆盖前面的ls -a（CMD ["ls","-a"]），但是我们知道-l不是个命令，要是我们追加一个ls -al，那ls -al就会覆盖前面，ls -al是一个命令就能生效。

测试ENTRYPOINT

这个就会追加了,ls -al都能执行，具体可以自己敲一下，我就不上了。放个狂神的截图。

实战测试2

制作一个tomcat镜像。

1、准备镜像文件需要的文件，tomcat压缩包，还需要jdk环境，一个jdk的压缩包。

2、编写dockerfile文件，官方的命名一般是Dockerfile，最好有一个readme.txt的帮助说明使用。

取名为Dockerfile，build的时候就会自动寻找这个文件，这就不需要-f指定了，它会默认扫描叫这个名字的文件。很多idea都已经默认了。

[root@iZ2zec103hcivif4pv3ai2Z tomcat-docker]# vim Dockerfile   #创建dockerfile文件

FROM  centos  #基础层，起于centos
MAINTAINER lwq<2018305346@qq.com>  #作者信息

COPY readme.txt  /usr/local/readme.txt  # 把readme.txt帮助文件拷贝到容器的 /usr/local下，因为是.当前文件夹运行，所以readme.txt直接写了，就在当前路径下

ADD jdk-8u171-linux-x64.tar.gz  /usr/local/  #把jdk压缩包放进容器，add命令会自动为我们解压，所以直接添加压缩包，无需你解压
ADD apache-tomcat-8.5.35.tar.gz /usr/local/  #把tomcat压缩包放进容器，add命令会自动为我们解压，所以直接添加压缩包，无需你解压

RUN yum -y install vim  # 下载vim命令

ENV MYPATH  /usr/local   # 环境变量
WORKDIR $MYPATH   # 设置工作路径，进入容器默认就是这个路径

ENV  JAVA_HOME /usr/local/jdk1.8.0_171  #以下是配置jdk和tomcat的环境变量，你在windos安装的时候也是这个，一个原理，只不过这个是写在脚本里的，多百度
ENV  CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV  CATALINA_HOME  /usr/local/apache-tomcat-8.5.35
ENV  CATALINA_BASH  /usr/local/apache-tomcat-8.5.35
ENV  PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE  8080   # 暴露下容器的端口

#运行镜像时执行这个命令，就是启动容器内的tomcat,并且打印日志，两个命令可以一起执行，用&&隔开
CMD  /usr/local/apache-tomcat-8.5.35/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.35/bin/logs/catalina.out

3、构建docker镜像

# docker build -t lwqdivtomcat .      #Dockerfile这个名字默认扫描，不用写-f了，构建一个目标名叫lwqdivtomcat的镜像，-t是目标的意思，target

Successfully built 9a44d38a8da4
Successfully tagged lwqdivtomcat:latest

4、启动构建成功的docker镜像

# 启动，并设置数据卷挂载，挂载tomcat一些需要的路径
docker run -d -p 8080:8080   --name lwqdivtomcat  -v /home/lwq/build/tomcat/test:/usr/local/apache-tomcat-8.5.35/webapps/test -v /home/lwq/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-8.5.35/logs  lwqdivtomcat

5、访问测试

# 浏览器访问tomcat页面发现成功
http://182.92.152.71:8080/

6、发布项目（由于做了卷挂载，我们直接在本地的挂载目录编写项目就可以发布了），创建发布项目需要的文件，模拟建立一个简单的项目：

# 1、cd  /home/lwq/build/tomcat/test(对应容器内的apache-tomcat-8.5.35/webapps/test)，test就相当于我们项目那个文件夹了
# 创建WEB-INF文件夹：mkdir WEB-INF
# 在WEB-INF中创建web.xml文件（模拟一个项目）

web.xml

  <web-app xmlns="http://java.sun.com/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                               http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
           version="2.5">

  web-app>

然后在test文件夹下，创建一个页面，用于访问，index.jsp

# cd ..   #进入test文件夹
# vim index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>







恭喜你docker入门了，运行了自己制作的tomcat-------------------lwq自己div的tomcat镜像--------------------

<%
System.out.println("-------------------lwq自己div的tomcat镜像--------------------");
%>

此时容器内部挂载的也就有了这些文件。

访问项目：http://182.92.152.71:8080/test/

…上传镜像后面写。