docker部署容器

一、docker 安装 nginx
二、docker 安装 tomcat
三、docker部署es+kibana
- 3.1、可视化portainer
四、docker镜像详解
- 4.1、镜像是什么？
- 4.2、镜像的获取途径
- 4.3、联合文件系统
- 4.4、提交自己的镜像
五、容器数据卷
- 5.1 、为什么用卷技术？
- 5.2 、如何使用数据卷？
- 5.3 、安装MySql
- 5.4、具名挂载和匿名挂载
- - 匿名挂载
  - 具名挂载
  - 小结
  - 扩展
六、初始Dockerfile
- 6.1、什么是Dockerfile？
- - 构建步骤：
  - dockerfile实战
- 6.2 数据卷容器
- - 案例1：多个容器之间的数据同步
  - 案例2：MySql容器实现数据同步
- 6.3、==dockerfile构建步骤==
- - 构建步骤：
  - 官方镜像
- 6.4、==dockerfile构建过程==
- - dockerfile脚本文件语法
  - dockerfile
  - dockerfile指令说明
  - CMD 和ENTRYPOINT区别
- 6.5、构建一个centos镜像（实战）
七、Dockerfile制作tomcat镜像
- 7.1、制作tomcat镜像
- 7.2、将自己镜像发布到Docker Hub
- 7.3、将自己的镜像发布到阿里云
总结：

一、docker 安装 nginx

# 搜索镜像
docker search nginx
# 下载镜像
docker pull nginx  # 默认下载最新版本
# 运行测试
docker images
[root@gitShile /]# docker images
REPOSITORY   TAG       IMAGE ID
nginx        latest    605c77e624dd  # -d 后台运行
# --name 给容器命名
# -p 宿主机端口，容器内部端口
# 9000  开发的端口号
[root@gitShile /]# docker run -d --name nginx01 -p 9000:80 nginx
b4f52d156dc841c71cac2956092b24743fdadd99febacf6a725e38e59919a491
[root@gitShile /]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                  NAMES
b4f52d156dc8   nginx     "/docker-entrypoint.…"   6 seconds ago   Up 5 seconds   0.0.0.0:9000->80/tcp   nginx01
[root@gitShile /]# curl localhost:9000
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p># 进入容器
[root@gitShile /]# docker exec -it nginx01 /bin/bash
# 查看nginx位置
root@b4f52d156dc8:/# whereis nginx
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@b4f52d156dc8:/# cd /etc/nginx/
root@b4f52d156dc8:/etc/nginx# ls
# 退出
root@b4f52d156dc8:/etc/nginx# exit
exit
# 停止容器
[root@gitShile /]# docker stop b4f52d156dc8
b4f52d156dc8

二、docker 安装 tomcat

# 官方使用
docker run -it --rm tomcat:9.0  一般用于测试，用完即删# 下载启动
docker pull tomcat:9.0
docker run -d -p 9000:8080# 进入容器，发现问题
[root@gitShile /]# docker exec -it tomcat01 /bin/bash# 问题： 1、Linux 命令少了   2、缺少webapps
# 原因： 阿里云镜像原因，默认是最小的镜像，所有不必要的都已经被剔除，之保证最小的运行环境# 将webapps.dist文件夹里的所有东西复制到webapps文件夹下，之后外网访问tomcat即可成功
root@67776a423f61:/usr/local/tomcat# cp -r  webapps.dist/* webapps

三、docker部署es+kibana

# 注意： elasticsearch 启动的时候非常消耗内存，因此需要设置内存限制，修改文件配置
# 启动elasticsearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
# 查看cup的使用
docker stats
# 测试es是否启动成功
curl localhost：9200# 增加内存限制，修改配置文件 -e 环境配置修改
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

3.1、可视化portainer

portainer是docker图形化界面管理工具，提供一个后台面板

# 安装命令
docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer#测试
docker ps

四、docker镜像详解

4.1、镜像是什么？

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

4.2、镜像的获取途径

远程仓库下载
copy他人镜像
自己制作镜像

4.3、联合文件系统

UnionFS（联合文件系统）

UnionFS （联合文件系统）是一种分层、轻量级并且高性能的文件系统，它支持对文研系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下，Union文件系统是Docker镜像的基础。docker 的镜像实质上是由一层一层文件系统组成，这种层级的文件系统称之为UnionFS联合文件系统。

特点：

一次可以同时加载多个文件系统，但是在外界看来，只能看到外文件系统，联合加载会把各种系统叠加起来，最终的文件系统会包含所有底层的文件和目录。

作用：

相同层次文件可复用
资源共享

查看镜像分层命令

docker image inspect
# 案例
[root@gitShile /]# docker pull redis
Using default tag: latest
latest: Pulling from library/redis
a2abf6c4d29d: Already exists
c7a4e4382001: Pull complete
4044b9ba67c9: Pull complete
c8388a79482f: Pull complete
413c8bb60be2: Pull complete
1abfd3011519: Pull complete
Digest: sha256:db485f2e245b5b3329fdc7eff4eb00f913e09d8feb9ca720788059fdc2ed8339
Status: Downloaded newer image for redis:latest
docker.io/library/redis:latest
[root@gitShile /]# docker image inspect redis
["RootFS": {"Type": "layers","Layers": [                "sha256:2edcec3590a4ec7f40cf0743c15d78fb39d8326bc029073b41ef9727da6c851f",
"sha256:9b24afeb7c2f21e50a686ead025823cd2c6e9730c013ca77ad5f115c079b57cb"，               "sha256:4b8e2801e0f956a4220c32e2c8b0a590e6f9bd2420ec65453685246b82766ea1",             "sha256:529cdb636f61e95ab91a62a51526a84fd7314d6aab0d414040796150b4522372"，              "sha256:9975392591f2777d6bf4d9919ad1b2c9afa12f9a9b4d260f45025ec3cc9b18ed",
"sha256:8e5669d8329116b8444b9bbb1663dda568ede12d3dbcce950199b582f6e94952"]}
]

所有docker镜像都起始于一个基础镜像层，当进行修改或者增加新的内容时，就会在当前镜像层之上创建新的镜像层。

特点：

Docker镜像都是可读的，当容器启动时，一个新的可写层被加载到镜像的顶部，这一层通常就是容器层，容器之下的都是镜像层。

4.4、提交自己的镜像

# 命令
docker commit -m="提交的描述信息"  -a="作者" 容器id 目标镜像名:[TAG]

案例：

由于默认的Tomcat镜像的webapps文件夹中没有任何内容，需要从webapps.dist中拷贝文件到webapps文件夹。下面自行制作镜像：就是从webapps.dist中拷贝文件到webapps文件夹下，并提交该镜像作为一个新的镜像。使得该镜像默认的webapps文件夹下就有文件。具体操作如下：

1、启动tomcat

# 启动tomcat
docker reun -it -p 8080:8080 tomcat
# 查看容器
docker ps
# 进入容器
docker exec -it 容器id  /bin/bash

2、制作镜像

# 拷贝 （将webappas.dist里所有文件拷贝到webapps下）
cp -r webapps.dist/* webapps
# 提交镜像，先提交本地，后发布远程仓库中
docker commit -m="提交内容" -a="作者" 容器id 目标镜像名：版本
//docker commit -m="提交的描述信息"  -a="作者" 容器id 目标镜像名:[TAG]
[root@gitShile /]# docker commit -m="add webapps application"  -a="shile" 6df1e3c4a230 tomcat01:1.0
sha256:e699f08da20e848d7a9bd7c8953b63500abe1ea6a6605838dc9f97876857c229
[root@gitShile /]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
tomcat01             1.0       a99a0b499daf   16 hours ago    684MB
nginx                 latest    605c77e624dd   4 months ago    141MB
tomcat                9.0       b8e65a4d736d   4 months ago    680MB

3、测试启动

# 启动
[root@gitShile /]# docker run -it -p 8080:8080 tomcat01:1.0
# 测试  外网访问tomcat

五、容器数据卷

思考问题：数据存放在容器里，如果把容器删除，则数据也会随之丢失，此时、为了保证数据的持久性，即删除容器时，保证数据不丢失（删库跑路）,就要用到数据卷。

5.1 、为什么用卷技术？

容器的持久层和同步操作，容器也是可以数据共享。

5.2 、如何使用数据卷？

将数据进行挂载，挂载后主机目录和容器目录共享一个目录资源，容器目录也可以理解为主机目录的快捷方式。

方式一：直接使用命令进行挂载

# 命令
docker run -it -v 主机目录:容器目录 -p 主机端口:容器内端口
#查看容器
docker ps
# 查看容器挂载
docker inspect 容器id

1、挂载并进入命令行 /bin/bash

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

[root@gitShile /]# docker run -it -v /home/ceshi:/home centos /bin/bash
[root@286ccc2c07c5 /]# cd home
[root@286ccc2c07c5 home]# ls #空

[root@gitShile /]# cd /home
[root@gitShile home]# ls
ceshi
[root@gitShile home]# cd ceshi/
[root@gitShile ceshi]# ls #空

2、查看挂载

# 命令
docker inspect 容器id[root@gitShile /]# docker inspect 286ccc2c07c5"Mounts": [{"Type": "bind","Source": "/home/ceshi","Destination": "/home","Mode": "","RW": true,"Propagation": "rprivate"}

3、测试挂载

挂载后主机目录和容器目录共享一个目录资源，容器目录也可以理解为是主机目录的快捷方式

[root@gitShile ~]# docker run -it -v /home/ceshi:/home centos /bin/bash
[root@9215507d44ea /]# cd home/
# 创建文件
[root@9215507d44ea home]# touch test.java
[root@9215507d44ea home]# ls
test.java
# 向文件里写入数据
[root@9215507d44ea home]# echo "this is test.java" > test.java
[root@9215507d44ea home]# cat test.java
this is test.java

# 进入本地home
[root@gitShile ~]# cd /home/
[root@gitShile home]# ls
ceshi
[root@gitShile home]# cd ceshi/
[root@gitShile ceshi]# ls
test.java
# 查看文件内容
[root@gitShile ceshi]# cat test.java
this is test.java

当把容器进行关闭的时候，数据依旧存在。

好处：今后只需修改本地即可，容器可以自动同步

5.3 、安装MySql

思考： mysql数据持久化问题。

# 获取镜像
docker pull mysql:5.7
# 运行容器，需要容器挂载
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 mysql01 mysql# 启动
-d 后台运行
-p 映射端口
-v 数据卷挂载
-e 环境配置
--name 容器名字
[root@gitShile /]# 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 mysql01 mysql
4c6dc6297f41129e5dd34076dd47854ad8f0264f2f5f7dd0b8cdcf5d8c3d21d3# 启动成功之后，在本地使用Navicat进行测试连接，如果连接不成功，可能是阿里云服务器3310端口没有开放，登入阿里云在安全组配置即可，也有可能是权限不够，在服务器上修改权限即可
# 在本地测试创建一个数据库，查看一下映射路径是否ok
[root@gitShile mysql]# ls
conf  data
[root@gitShile mysql]# cd data/
[root@gitShile data]# ls
auto.cnf    client-cert.pem  ib_buffer_pool  ib_logfile1  performance_schema  server-cert.pem
ca-key.pem  client-key.pem   ibdata1         ibtmp1       private_key.pem     server-key.pem
ca.pem      docker_test      ib_logfile0     mysql        public_key.pem      sys

当删除容器时,挂载本地的数据卷依旧存在，这就实现数据持久化功能!

[root@gitShile /]# docker rm -f mysql01
mysql01

5.4、具名挂载和匿名挂载

卷指容器被挂载的主机目录

匿名挂载

1、匿名挂载就是不指定主机目录进行挂载（没有给卷（主机目录）起名就是匿名）

docker run -d -P --name nginx01 -v /etc/nginx nginx
# -P 随机指定端口
# -v 容器内路径

2、查看所有的volume（卷）的情况

# 命令
docker volume ls

[root@gitShile ~]# docker volume ls
DRIVER    VOLUME NAME
local     84d5b9699c4e66f5d0568de81eec296360b0ec50b6efae508ac6f0aee79efaca
local     665a2a265b58266f365964e75456f2187fcdc2ff268559038b6d26e1a9e88879

3、指定卷来查看挂载

# 命令
docker volume inspect 卷名

[root@gitShile ~]# docker volume inspect 84d5b9699c4e66f5d0568de81eec296360b0ec50b6efae508ac6f0aee79efaca
[{"CreatedAt": "2022-05-12T22:25:26+08:00","Driver": "local","Labels": null,"Mountpoint": "/var/lib/docker/volumes/84d5b9699c4e66f5d0568de81eec296360b0ec50b6efae508ac6f0aee79efaca/_data","Name": "84d5b9699c4e66f5d0568de81eec296360b0ec50b6efae508ac6f0aee79efaca","Options": null,"Scope": "local"}
]

具名挂载

1、具名挂载就是指定了主机目录进行的挂载

# 命令
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

[root@gitShile ~]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
68388ec051c068ed636f8cb8ef42f81f4e05cd88544afd7217bb07ced3f17355

2、查看所有volume(卷)的情况

[root@gitShile ~]# docker volume ls
DRIVER    VOLUME NAME
local     84d5b9699c4e66f5d0568de81eec296360b0ec50b6efae508ac6f0aee79efaca
local     665a2a265b58266f365964e75456f2187fcdc2ff268559038b6d26e1a9e88879
local     juming-nginx

3、指定卷来查看挂载

[root@gitShile ~]# docker volume inspect juming-nginx
[{"CreatedAt": "2022-05-15T22:24:09+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/volumes/**==下，如果指定目录，docker volume ls是查不到的。

小结

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

扩展

通过 -v 容器内路径： ro rw 改变读写权限

ro #readonly 只读
rw #readwrite 可读可写
docker run -d -P --name nginx05 -v juming:/etc/nginx:ro nginx
docker run -d -P --name nginx05 -v juming:/etc/nginx:rw nginx

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

六、初始Dockerfile

6.1、什么是Dockerfile？

Dockerfile是用来构建docker镜像的构建文件，实际上是一段命令脚本。

构建步骤：

创建一个dockerfile文件，名字随机，但是文件内容指定（大写参数）
docker build 构建一个镜像
docker run 运行镜像
docker pull 发布镜像

dockerfile实战

1、在home文件加载

[root@gitShile home]# mkdir docker_file
[root@gitShile home]# cd docker_file/
[root@gitShile docker_file]# pwd
/home/docker_file
[root@gitShile docker_file]# vim dockerfiler

2、编写dockerfile文件（dockerfiler）

# FROM 基础镜像，表示所有的一切从这里构建
# VOLUME 镜像目录
# CMD 指定这个容器启动的时候要进行的命令，只有最后一个会生效，可被替代
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "----this is end!----"
CMD /bin/bash
# 因为docker 的镜像是分层的，所以这里的每一个命令都是镜像的一层!

3、通过这个文件构建镜像

# 命令
# docker build -f 文件路径 -t 镜像名:[tag] .
[root@gitShile docker_file]# docker build -f dockerfiler -t shile/centos:1.0 .
Sending build context to Docker daemon  14.85kB
Step 1/4 : FROM centos---> 5d0da3dc9764
Step 2/4 : VOLUME ["volume01","volume02"]---> Running in 068483fdbad4
Removing intermediate container 068483fdbad4---> c2286332842d
Step 3/4 : CMD echo "----this is end!----"---> Running in d123693d8e86
Removing intermediate container d123693d8e86---> b963fee1fbae
Step 4/4 : CMD /bin/bash---> Running in 13a4dfe83e91
Removing intermediate container 13a4dfe83e91---> 338ec2653ef6
Successfully built 338ec2653ef6
Successfully tagged shile/centos:1.0

4、启动自己的容器

docker inspect 容器id

测试一下，刚才文件是否同步出去！

6.2 数据卷容器

容器挂载数据卷，实现容器间的数据同步和资源共享。

案例1：多个容器之间的数据同步

1、开启一个父容器docker01

2、开启第二个容器docker02并挂载到docker01的共享卷

3、在docker01中创建文件，查看docker02共享卷的变化

[root@526557e05c8d volume01]# touch dockertest.txt
[root@526557e05c8d volume01]# ls
dockertest.txt

4、再次创建一个docker03,再次查看时也实现了数据共享，此时，在docker01中删除volume01下的dockertest.txt文件时，docker02、docker03下的volume01下的数据也会随之删除

# 删除dockertest.txt 数据时，docker02,、docker03下的volume01中也无数据。
[root@526557e05c8d volume01]# rm -rf dockertest.txt
[root@526557e05c8d volume01]# ls
# 无数据

此时，若在docker03的volume01下重新创建test.java文件时，也会同步到docker01、docker02中

[root@bc6015108c51 volume01]# touch test.java
[root@bc6015108c51 volume01]# ls
test.java

结论：docker01、docker02、docker03实现了数据共享，当删除某个容器里的数据时，其他容器依旧保持数据同步和资源共享，这是一个双向绑定过程！

案例2：MySql容器实现数据同步

1、启动mysql01，绑定端口3306，设置密码:-e MYSQL_ROOT_PASSWORD=password,挂载卷==-v==

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

2、启动mysql02、mysql03

# mysql02
docker run -it --name mysql02 --volumes-from mysql01 -p 3100:3306 -e MYSQL_ROOT_PASSWORD=123456 -v /etc/mysql/conf.d -v /var/lib/mysql mysql# mysql03
docker run -it --name mysql03 --volumes-from mysql01 -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 -v /etc/mysql/conf.d -v /var/lib/mysql mysql

3、结论

容器之间配置信息的传递，数据卷容器的声明周期一直持续到没有容器使用为止!

6.3、dockerfile构建步骤

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

构建步骤：

编写一个dockerfile文件
docker build构建成为一个镜像
docker run 运行镜像
docker push 发布镜像（docker hub、阿里云镜像）

官方镜像

地址：https://hub.docker.com/_/centos

在docker中，有99%的镜像都是从FROM scratch(基础镜像)开始构建的。由于，很多官方镜像都是基础包，很多功能都没有，因此，通常需要自己重新搭建镜像满足功能的需求。

6.4、dockerfile构建过程

dockerfile脚本文件语法

每一个保留关键字（指令）都是必须大写的字母
执行流程是从上到下顺序
#表示注解
每一个指令都会去创建提交一个新的镜像层，并提交！

dockerfile

docker镜像是由特殊的文件系统叠加而成。

最底端是bootfs,并使用宿主机上的bootfs-复用

第二层是root文件系统roofs,称为基础镜像（base image）

往上就可以叠加其他的镜像文件。

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

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

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

dockerfile指令说明

指令	解释
FROM	基础镜像，一切从这里开始构建
MAINTAINER	镜像是谁写的，姓名+邮箱(翻译：维护人员)
RUN	镜像构建的时候需要运行的命令
ADD	步骤，tomcat镜像，这个tomcat压缩包！添加内容添加同目录
WORKDIR	镜像的工作目录
VOLUME	挂载的目录
EXPOSE	保留端口配置（开放的端口）
CMD	指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT	指定这个容器启动的时候要运行的命令，可以追加命令（入口点）
ONBUILD	当构建一个被继承 DockerFile 这个时候就会运行ONBUILD的指令，触发指令
COPY	类似ADD，将我们文件拷贝到镜像中
ENV	构建的时候设置环境变量！

CMD 和ENTRYPOINT区别

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

测试CMD

# 1. 编写dockerfile文件
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# vim dockerfile-cmd-test
FROM centos
CMD ["ls", "-a"]# 2. 构建镜像
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker build -f dockerfile-cmd-test -t cmdtest .# 3. run运行， 发现我们的ls -a 命令生效
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker run ebe6a52bb125
.
..
.dockerenv
bin
dev
etc
home
lib
lib64# 想追加一个命令 -l 变成 ls -al
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker run ebe6a52bb125 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\": executable file not found in $PATH": unknown.
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker run ebe6a52bb125 ls -l# cmd的情况下 -l替换了CMD["ls", "-a"]命令， -l不是命令，所以报错了

测试ENTRYPOINT

# 1. 编写dockerfile文件
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# vim dockerfile-entrypoint-test
FROM centos
ENTRYPOINT ["ls", "-a"]# 2. 构建文件
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker build -f dockerfile-entrypoint-test -t entrypoint-test .# 3. run运行 发现我们的ls -a 命令同样生效
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker run entrypoint-test
.
..
.dockerenv
bin
dev
etc
home
lib# 4. 我们的追加命令， 是直接拼接到ENTRYPOINT命令的后面的！
[root@iZ2zeg4ytp0whqtmxbsqiiZ dockerfile]# docker run entrypoint-test -l
total 56
drwxr-xr-x  1 root root 4096 Aug 13 07:52 .
drwxr-xr-x  1 root root 4096 Aug 13 07:52 ..
-rwxr-xr-x  1 root root    0 Aug 13 07:52 .dockerenv
lrwxrwxrwx  1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x  5 root root  340 Aug 13 07:52 dev
drwxr-xr-x  1 root root 4096 Aug 13 07:52 etc
drwxr-xr-x  2 root root 4096 May 11  2019 home
lrwxrwxrwx  1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx  1 root root    9 May 11  2019 lib64 -> usr/lib64
drwx------  2 root root 4096 Aug  9 21:40 lost+found

6.5、构建一个centos镜像（实战）

功能：搭建一个centos镜像，实现vim、ifconfig功能（docker官方的centos没有这些命令）

1、创建工作目录

 [root@gitShile home]# mkdir makecentosfile[root@gitShile makecentosfile]# pwd /home/makecentosfile[root@gitShile makecentosfile]# vim mydockerfile-centos

2、编写dockerfile文件（文件名：mydockerfile-centos）

FROM centos:centos7
MAINTAINER shile<760998254@qq.com>ENV MYPATH /usr/local # 设置环境变量
WORKDIR $MYPATH # 镜像的工作目录，进入镜像的初始目录# RUN: 镜像构建的时候需要运行的命令
RUN yum -y install vim      # 新增 vim 工具
RUN yum -y install net-tools # 新增 网络 工具 有ifconfig命令EXPOSE 80 # 开放的端口CMD echo $MYPATH
CMD echo "-----end----"
CMD /bin/bash

3、通过这个文件构建镜像

#命令  docker build -f 文件路径 -t 镜像名：[tag] .
docker build -f mydockerfile-centos  -t mycentos:1.0 .

查看本地进行的变更历史

使用该命令可以查看该镜像是如何构建的

# 命令
docker history [imageId]

七、Dockerfile制作tomcat镜像

7.1、制作tomcat镜像

前期准备： tomcat、jdk的压缩包

1、将本地压缩包上传到服务器上

2、编写dockerfile文件，官方命名Dockerfile，当进行build命令时会自动寻找这个文件

[root@gitShile tomcat]# vim Dockerfile
FROM centos
MAINTAINER root<760998254@qq.com>
COPY readme.txt /usr/local/readme.txt #复制文件
ADD jdk-8u181-linux-x64.tar.gz /usr/local/ #复制解压
ADD apache-tomcat-8.5.58.tar.gz /usr/local/
RUN yum -y install vimENV MYPATH /usr/local #设置环境变量
WORKDIR $MYPATH  #设置工作目录ENV JAVA_HOME /usr/local/jdk1.8.0_181
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools/jar
ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.58  #设置环境变量
ENV CATALINA_BASH /usr/local/apache-tomcat-8.5.58
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin  #设置环境变量 分隔符是：
EXPOSE 8080 #设置暴露的端口CMD /usr/local/apache-tomcat-8.5.58/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.58/bin/logs/catalina.out # 设置默认命令

3、启动镜像

[root@gitShile tomcat]# docker run -d -p 8080:8080 --name tomcat01 -v /home/tomcat/test:/usr/local/apache-tomcat-8.5.58/webapps/test -v /home/tomcat/tomcatlogs/:/usr/local/apache-tomcat-8.5.58/logs tomcart01:1.0

4、查看并执行

[root@gitShile tomcat]# ls
apache-tomcat-8.5.58.tar.gz  jdk-8u181-linux-x64.tar.gz  test
Dockerfile                   readme.txt                  tomcatlogs
[root@gitShile tomcat]# docker exec -it 2a8d8f1a2d5c /bin/bash
root@2a8d8f1a2d5c:/usr/local/tomcat# ls
BUILDING.txt     NOTICE     RUNNING.txt  lib         temp      work
CONTRIBUTING.md  README.md  bin      logs        webapps
LICENSE      RELEASE-NOTES  conf         native-jni-lib  webapps.dist
root@2a8d8f1a2d5c:/usr/local/tomcat# pwd
/usr/local/tomcat
root@2a8d8f1a2d5c:/usr/local/tomcat# ls -l
total 160
-rw-r--r-- 1 root root 18994 Dec  2 22:01 BUILDING.txt
-rw-r--r-- 1 root root  6210 Dec  2 22:01 CONTRIBUTING.md
-rw-r--r-- 1 root root 60269 Dec  2 22:01 LICENSE
-rw-r--r-- 1 root root  2333 Dec  2 22:01 NOTICE
-rw-r--r-- 1 root root  3378 Dec  2 22:01 README.md
-rw-r--r-- 1 root root  6905 Dec  2 22:01 RELEASE-NOTES
-rw-r--r-- 1 root root 16517 Dec  2 22:01 RUNNING.txt
drwxr-xr-x 2 root root  4096 Dec 22 17:07 bin
drwxr-xr-x 1 root root  4096 May 13 15:04 conf
drwxr-xr-x 2 root root  4096 Dec 22 17:06 lib
drwxrwxrwx 1 root root  4096 May 27 07:22 logs
drwxr-xr-x 2 root root  4096 Dec 22 17:07 native-jni-lib
drwxrwxrwx 2 root root  4096 Dec 22 17:06 temp
drwxr-xr-x 1 root root  4096 May 13 15:08 webapps
drwxr-xr-x 7 root root  4096 Dec  2 22:01 webapps.dist
drwxrwxrwx 1 root root  4096 May 13 15:08 work

5、服务器测试访问tomcat

[root@gitShile ~]# curl localhost:8080
<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8" /><title>Apache Tomcat/10.0.14</title><link href="favicon.ico" rel="icon" type="image/x-icon" /><link href="tomcat.css" rel="stylesheet" type="text/css" /></head><body>....

外网访问：

6、发布项目

在本地test里添加web.xml和index.jsp测试，直接访问即可！

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"></web-app>

<%@ page language="java" contentType="text/html; charset=UTF-8"pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html><head><meta charset="utf-8"><title>tomcat</title></head><body>Hello World!<br/></body>
</html>

7.2、将自己镜像发布到Docker Hub

1、在Docker Hub上注册自己的账号

地址：https://hub.docker.com/

2、在终端进行登录

# 命令
docker login -u 用户名
password:   #输入docker hub密码

3、提交push镜像

[root@gitShile ~]# docker images
REPOSITORY            TAG       IMAGE ID       CREATED         SIZE
diytomcat             latest    a68cf8f3e222   12 hours ago    930MB

打标签

# docker tag 镜像id 你的账户名/镜像仓库名:tag名
docker tag a68cf8f3e222 dockershile/diytomcat:latest

提交镜像

# docker push 作者/镜像:TAG(版本)
docker push dockershile/diytomcat:latest

7.3、将自己的镜像发布到阿里云

官方文档地址：https://cr.console.aliyun.com/repository/

1、登录阿里云服务器

2、找到容器镜像服务

3、创建命名空间

总结：

学习资源：https://www.bilibili.com/video/BV1og4y1q7M4?p=30&spm_id_from=333.880.my_history.page.click

Docker Hub地址：https://hub.docker.com/

官方文档地址：https://cr.console.aliyun.com/repository/