Docker

Docker概述

Docker为什么会出现

一款产品从开发到上线，从操作系统，到运行环境，再到应用配置。作为开发+运维之间的协作我们需要关心很多东西，这也是很多互联网公司都不得不面对的问题，特别是各种版本的迭代之后，不同版本环境的兼容，对运维人员是极大的考验！

环境配置如此麻烦，换一台机器，就要重来一次，费力费时。很多人想到，能不能从根本上解决问题，软件可以带环境安装？也就是说，安装的时候，把原始环境一模一样地复制过来。解决开发人员说的“ 在我的机器上可正常工作”的问题。

之前在服务器配置一个应用的运行环境，要安装各种软件，就拿一个基本的工程项目的环境来说吧，Java/Tomcat/MySQL/JDBC驱动包等。安装和配置这些东西有多麻烦就不说了，它还不能跨平台。假如我们是在 Windows 上安装的这些环境，到了 Linux 又得重新装。况且就算不跨操作系统，换另一台同样操作系统的服务器，要移植应用也是非常麻烦的。

传统上认为，软件编码开发/测试结束后，所产出的成果即是程序或是能够编译执行的二进制字节码文件等（Java为例）。而为了让这些程序可以顺利执行，开发团队也得准备完整的部署文件，让维运团队得以部署应用程式，开发需要清楚的告诉运维部署团队，用的全部配置文件+所有软件环境。不过，即便如此，仍然常常发生部署失败的状况。

Docker之所以发展如此迅速，也是因为它对此给出了一个标准化的解决方案。

Docker镜像的设计，使得Docker得以打破过去「程序即应用」的观念。通过Docker镜像 ( images ) 将应用程序所需要的系统环境，由下而上打包，达到应用程序跨平台间的无缝接轨运作。

Docker的思想来自于集装箱，集装箱解决了什么问题？在一艘大船上，可以把货物规整的摆放起来。并且各种各样的货物被集装箱标准化了，集装箱和集装箱之间不会互相影响。那么我就不需要专门运送水果的船和专门运送化学品的船了。只要这些货物在集装箱里封装的好好的，那我就可以用一艘大船把他们都运走。

docker就是类似的理念。

历史

2010年，几个搞IT的年轻人，在美国旧金山成立了一家名叫“dotCloud”的公司。

这家公司主要提供基于PaaS的云计算技术服务。具体来说，是和LXC有关的容器技术。

后来，dotCloud公司将自己的容器技术进行了简化和标准化，并命名为——Docker。

Docker技术诞生之后，并没有引起行业的关注。而dotCloud公司，作为一家小型创业企业，在激烈的竞争之下，也步履维艰。

正当他们快要坚持不下去的时候，脑子里蹦出了“开源”的想法。

什么是“开源”？开源，就是开放源代码。也就是将原来内部保密的程序源代码开放给所有人，然后让大家一起参与进来，贡献代码和意见。

有的软件是一开始就开源的。也有的软件，是混不下去，创造者又不想放弃，所以选择开源。自己养不活，就吃“百家饭”嘛。

2013年3月，dotCloud公司的创始人之一，Docker之父，28岁的Solomon Hykes正式决定，将 Docker项目开源。

不开则已，一开惊人。

越来越多的IT工程师发现了Docker的优点，然后蜂拥而至，加入Docker开源社区。

Docker的人气迅速攀升，速度之快，令人瞠目结舌。

开源当月，Docker 0.1 版本发布。此后的每一个月，Docker都会发布一个版本。到2014年6月9日， Docker 1.0 版本正式发布。

此时的Docker，已经成为行业里人气最火爆的开源技术，没有之一。甚至像Google、微软、Amazon、 VMware这样的巨头，都对它青睐有加，表示将全力支持。

Docker和容器技术为什么会这么火爆？说白了，就是因为它“轻”。

在容器技术之前，业界的网红是虚拟机。虚拟机技术的代表，是VMWare和OpenStack。

相信很多人都用过虚拟机。虚拟机，就是在你的操作系统里面，装一个软件，然后通过这个软件，再模拟一台甚至多台“子电脑”出来。

在“子电脑”里，你可以和正常电脑一样运行程序，例如开QQ。如果你愿意，你可以变出好几个“子电脑”，里面都开上QQ。“子电脑”和“子电脑”之间，是相互隔离的，互不影响。

虚拟机属于虚拟化技术。而Docker这样的容器技术，也是虚拟化技术，属于轻量级的虚拟化。

虚拟机虽然可以隔离出很多“子电脑”，但占用空间更大，启动更慢，虚拟机软件可能还要花钱（例如 VMWare）。

而容器技术恰好没有这些缺点。它不需要虚拟出整个操作系统，只需要虚拟一个小规模的环境（类似“沙箱”）。

它启动时间很快，几秒钟就能完成。而且，它对资源的利用率很高（一台主机可以同时运行几千个 Docker容器）。此外，它占的空间很小，虚拟机一般要几GB到几十GB的空间，而容器只需要MB级甚至 KB级。

正因为如此，容器技术受到了热烈的欢迎和追捧，发展迅速。

docker理念

Docker是基于Go语言实现的云开源项目。

Docker的主要目标是“Build，Ship and Run Any App , Anywhere”，也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次封装，到处运行”。

Linux 容器技术的出现就解决了这样一个问题，而 Docker 就是在它的基础上发展过来的。将应用运行在 Docker 容器上面，而 Docker 容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器。只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作。

Docker能干嘛

之前的虚拟机技术

虚拟机（virtual machine）就是带环境安装的一种解决方案。

它可以在一种操作系统里面运行另一种操作系统，比如在Windows 系统里面运行Linux 系统。应用程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样，而对于底层系统来说，虚拟机就是一个普通文件，不需要了就删掉，对其他部分毫无影响。这类虚拟机完美的运行了另一套系统，能够使应用程序，操作系统和硬件三者之间的逻辑不变

虚拟机的缺点:

1. 资源占用多
1. 冗余步骤多
1. 启动慢

容器虚拟化技术

由于前面虚拟机存在这些缺点，Linux发展出了另外一种虚拟化技术:Linux容器(Linux Containers,所写为LXC)。

Linux容器不是模拟一个完整的操作系统，而是对进程进行隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同。不需要捆绑一整套操作系统，只需要软件工作所需的库资源和配置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。

比较了Docker和传统虚拟化的不同之处:

传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；
而容器的应用进程直接运行与宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
每个容器之间像话隔离，每个容器有自己的文件系统，容器之间进程不会相互影响，能区分计算资源。

开发/运维(DevOps)

更快速的应用交付和部署:

传统的应用开发完成后，需要提供一堆安装程序和配置说明文档，安装部署后需根据配置文档进行繁琐的配置才能正常运行。Docker化之后只需要交付少量容器镜像文件，在正式生产环境加载镜像并运行即可，应用安装配置在镜像里已经内置好，大大节省配置和测试验证时间。

更便捷的升级和扩缩容：

随着微服务架构和Docker的发展，大量的应用会通过微服务方式架构，应用的开发构建将变成搭乐高积木一样，每个Docker容器将变成一块"积木"，应用的升级将变得非常容易。当现有的容器不足以支撑业务处理时，可通过镜像运行新的容器进行快速扩容，使应用系统的扩容从原先的天极变成分钟级甚至秒级。

更简单的系统运维:

应用容器话运行后，生产环境运行的应用可与开发、测试环境的应用高度一致，容器会将应用程序相关的环境和状态完全封装起来，不会因为底层基础架构和操作系统的不一致性给应用带来影响，产生新的BUG。当出现程序异常时，也可以通过测试环境的相同容器进行快速定位和修复。

更高效的计算资源利用：

Docker是内核级虚拟化，其不像传统的虚拟化技术一样需要额外的Hypervisor[管理程序]支持，所以在一台物理机上可以运行很多个容器实例，可大大提升物理服务器的CPU和内存的利用率。

学习途径

Docker官网:Home - Docker

Docker中文网站:https://dockerdocs.cn/

Docker Hub官网:https://hub.docker.com/

Docker安装

Docker的基本组成

Docker的架构图

镜像(image):

Docker镜像(image)就是一个只读的模板。镜像可以用来创建Docker容器，一个镜像可以创建很多容器。就好似Java中的类和对象，类就是镜像，容器就是对象!

容器(container):

Docker利用容器(container)独立运行的一个或一组应用。容器是用镜像创建的运行实例。

它可以被启动、开始、停止、删除。每个容器都是相互隔离的，保证安全点的平台。

可以把容器看做是一个简易版的Linux环境(包括root用户权限、进程空间、用户空间和网络空间等)和运行在其中的应用程序。。

容器的定义和镜像几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的。

仓库(repository):

仓库(repository)是集中存放镜像文件的场所。

仓库(repostory)和仓库注册服务器(Registry)是有区别的。仓库注册服务器上往往存放着多个仓库，每个仓库中又包括多个镜像，每个镜像有不同的标签(tag)。

仓库分为公开仓库(Public)和私有仓库(private)两种形式。

最大的公开仓库是Docker Hub(https://hub.docker.com/)，存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等

小结:

需要正确的理解仓储/镜像/容器这几个概念:

- Docker本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就似乎image镜像文件。只有通过这个镜像文件才能生成同一个image文件，可以生成多个同时运行的容器实例。
- image文件生成的容器实例，本身也是一个文件，称为镜像文件。
- 一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例。也就是我们的容器。
- 至于仓库，就是放了一堆镜像的地方，我们可以把镜像发布到仓库中，需要的时候从仓库中来下来就可以了。

环境说明

我们使用的是Centos7

Docker运行在Centos7上，要求系统为64位、系统内核版本为3.10以上

查看自己的内核:

unam -r 命令用于打印当前系统相关信息(内核版本号、硬件架构、主机名称和操作系统类型等)。

[root@root~]# uname -r

查看版本信息:

[root@root~]# cat /etc/os-release

安装步骤

1、官网安装参考手册:安装手册

2、确定你是Centos7及以上版本，我们已经做过了

3、yum安装gcc相关环境

yum -y install gcc
yum -y install gcc-c++

4、卸载旧版本

yum remove docker \ 
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

5、安装需要的软件包

yum install -y yum-utils

6、设置镜像仓库

#错误
yum-config-manager  -add-repo
https://download.docker.com/linux/centos/docker-ce.repo
## 报错
[Errno 14] curl#35 - TCP connection reset by peer
[Errno 12] curl#35 - Timeout

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

7、更新yum软件包索引

yum makecache fast

8、安装Docker CE

yum install docker-ce docker-ce-cli containerd.io

9、启动Docker

systemctl start docker

10、测试命令

docker version

docker run hello-world

docker images

11、卸载

systemctl  stop docker

yum -y remove docker-ce docker-ce-cli containerd.io

rm -rf /var/lib/docker

阿里云镜像加速

1、介绍:https://www.aliyun.com/product/acr

2、注册一个属于自己的阿里云账户

3、进入管理控制台设置密码，开通

4、查看镜像加速器自己的

5、配置镜像加速

sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://qiyb9988.mirror.aliyuncs.com"]
}
EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

测试HelloWorld

1、启动hello-world

docker run hello-world

2、run干了什么?

底层原理

Docker是怎样工作的

Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境，就是我们前面说到的集装箱。

为什么Docker比VM快

1、docker有着比虚拟机更少的抽象层。由于docker不需要Hypervisor实现硬件资源虚拟化，运行在docker容器上的程序直接使用的都是实际物理的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。

2、docker利用的是宿主机的内核，而不需要Guest OS。因此，当新建一个容器时，docker不需要和虚拟机一样重新加载一个操作系统内核。而避免引寻、加载操作系统内核返回比较费时费资源的过程，当新建一个虚拟机时，虚拟机软件需要加载GuestOS，返个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统，则省略了返个过程，因此新建一个docker容器只需要几秒钟。

Docker常用命令

帮助命令

docker version 显示docker的版本信息
docker info 显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help 帮助命令

帮助文档: https://docs.docker.com/engine/reference/commandline/

镜像命令

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

[root@VM-8-7-centos home]# docker images REPOSITORY TAG IMAGE ID CREATED SIZE centos latest 5d0da3dc9764 8 months ago 231MB

解释：

REPOSITORY 镜像的仓库

TAG 镜像的标签

IMAGE ID 镜像的id

CREATED 镜像的创建时间

SIZE 镜像的代销

可选项:

-a,—all 列出所有镜像

-q,—quiet 只显示镜像的id
docker search 搜索镜像

[root@VM-8-7-centos ~]# docker search mysql

NAME DESCRIPTION STARS OFFICIAL AUTOMATED

mysql MySQL is a widely used, open-source relation… 12590 [OK] mariadb MariaDB Server is a high performing open sou… 4839 [OK] percona Percona Server is a fork of the MySQL relati… 576 [OK] phpmyadmin phpMyAdmin - A web interface for MySQL and M… 540 [OK] bitnami/mysql Bitnami MySQL Docker Image
```
 可选项，通过搜索来过滤

  —filter=STARS=3000   搜索出来的镜像就是STARS大于3000的
```

[root@VM-8-7-centos ~]# docker search mysql --filter=STARS=3000

NAME DESCRIPTION STARS OFFICIAL AUTOMATED

mysql MySQL is a widely used, open-source relation… 12590 [OK]

mariadb MariaDB Server is a high performing open sou… 4839 [OK]

docker pull 下载镜像

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

[root@VM-8-7-centos ~]# docker pull mysql

Using default tag: latest #如果不写tag,默认就是latest

latest: Pulling from library/mysql

c32ce6654453: Pull complete #分层下载,docker image的核心联合文件系统

415d08ee031a: Pull complete

7a38fec2542f: Pull complete

352881ee8fe9: Pull complete

b8e20da291b6: Pull complete

66c2a8cc1999: Pull complete

d3a3a8e49878: Pull complete

e33a48832bec: Pull complete

410b942b8b28: Pull complete

d5323c9dd265: Pull complete

3212737f31c0: Pull complete

d0032d4b0dc5: Pull complete

Digest: sha256:a0805d37d4d298bd61e0dfa61f0ddf6f4680b453fa25d7aad420485a62417eab #签名 Status: Downloaded newer image for mysql:latest docker.io/library/mysql:latest #真实地址
```
 #等价于它

docker pull mysql

docker pull  [docker.io/library/mysql:latest](http://docker.io/library/mysql:latest)
```
#指定版本下载
```
docker pull  mysql:5.7
```

4.docker rmi 删除镜像

[root@VM-8-7-centos ~]# docker rmi -f 镜像id 删除指定的容器

[root@VM-8-7-centos ~]# docker rmi -f 镜像id 镜像id 镜像id 删除多个容器

[root@VM-8-7-centos ~]# docker rmi -f $(docker images -aq) 删除全部容器

容器命令

说明:我们有了镜像才可以创建容器，linux，下载一个centos镜像来测试学习

docker pull centos

新建容器并启动

docker run [可选参数] image

参数说明

—name="Name" 容器名字 tomcat01 tomcat02，用来区分容器

-d 后台方式运行

-it 使用交互方式运行，进入容器查看内容

-p 指定容器的端口 -p 8080:8080

-p ip:主机端口:容器端口

-p 主机端口:容器端口(常用)

-p 容器端口

容器端口

-P 随机指定端口

测试,启动并进入容器

[root@VM-8-7-centos ~]# docker run -it centos /bin/bash

[root@a2d649a254bb /]# ls #查看容器内的centos，基础版本，很多命令都是不完善的

bin etc lib lost+found mnt proc run srv tmp var dev home lib64 media opt root sbin sys usr

从容器中返回主机

[root@a2d649a254bb /]# exit
列出所有的运行的容器

docker ps 命令

#列出当前正在运行的容器

-a #列出当前正在运行的容器+带出历史运行过的容器

-n=? #显示最近创建的容器

[root@VM-8-7-centos ~]# docker ps -a

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

a2d649a254bb centos "/bin/bash" 7 minutes ago Exited (0) 4 minutes ago brave_kowalevski

2dc403fac419 centos "/bin/bash" About an hour ago Exited (0) About an hour ago nostalgic_benz

[root@VM-8-7-centos ~]#
退出容器

exit 直接容器停止并退出

ctrl + p + q 容器不停止退出
删除容器

docker rm 容器id 删除指定的容器，不能删除正在运行的容器，如果要强制删除 rm-f

docker rm -f $(docker ps -aq) 删除所有的容器

docker ps -a -q | xargs docker rm 删除所有的容器
启动和停止容器的操作

docker start 容器id 启动容器

docker restart 容器id 重启容器

docker stop 容器id 停止当前正在运行的容器

docker kill 容器id 强制停止当前容器

常用的其它命令

后台启动命令

#命令docker run -d 镜像名!

#问题docker ps，发现centos停止了

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

#nigix，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了
查看日志

docker logs -f -t —tail容器,没有日志

#自己编写一段shell脚本

#显示日志

-tf 显示日志

--tail number 要显示日志条数

查看容器中进程信息 ps

#命令 docker top 容器id
查看镜像的元数据

#docker inspect 容器id
进入当前正在运行的容器

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

#命令

docker exec -it 容器id bashshell

#测试

#方式二

docker attach 容器id

#测试

正在执行当前的代码。。。

#docker exec #进入容器后开启一个新的终端，可以在里面操作(常用)

#docker attach #进入容器正在执行的终端，不会启动新的进程!
从容器内拷贝文件到主机上

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

#将这文件拷贝出来到主机上

#拷贝是一个手动过程，未来我们使用-v 卷的技术，可以实现
Docker安装Nginx

#1、搜索镜像 search 建议大家去docker搜索，可以看到帮助文档

#2、下载镜像 pull

#3、运行测试

-d 后台运行

--name 给容器命名

-p 宿主机端口:容器内部端口

思考问题:我们每次改动nginx配置文件，都需要进入容器内部?十分的麻烦，我要是可以在容器外部提供一个映射路径，达到在容器修改文件名，容器内部就可以自动修复? -v数据卷

作业练习

Docker 安装Nginx

搜索镜像 search 建议大家去docker搜索，可以看到帮助文档
下载镜像 pull
运行测试

-d 后台运行

--name 给容器命名

-p 宿主机端口:容器内部端口

端口暴露的概念

思考问题:我们每次改动nginx配置文件，都需要进入容器内部？十分的麻烦，我要是可以在容器外部提供一个映射路径，达到在容器修改文件名，容器内部就可以自动修改? -v数据卷!

作业:docker来装tomcat

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

#下载再启动
docker pull tomcat
#启动运行
docker run -d -p 3355:8080 --name tomcat01 tomcat

#测试访问没有问题

#进入容器
docker exec -it tomcat01 /bin/bash
#发现问题,1、linux命令少了，2、没有webapps、阿里云镜像的原因、默认是最小的镜像，所以不必要的都剔除掉
#保证最小可运行的环境!

思考问题:我们以后要部署项目，如果每次都要进入容器是不是很麻烦？要是可以在容器外部提供一个映射路径，webapps,我们在外部部署项目，就自动同步到内部就好了

作业:部署es+kibana

# es 暴露的端口很多
# es 十分的耗内存
# es 的数据一般需要放置到安全目录！挂载
# --net somenetwork ? 网络配置
#启动elasticsearch 
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery ,type=single-node" elasticsearch:7.6.2

#启动了linux就卡住了  docker stats 查看 cpu的状态
# es是十分耗内存的
#查看docker stats
# 测试一下es是够成功了
[root@kuangshen home]# 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
#查看 docker stats

可视化

portainer(先用这个)

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

Rancher(CI/CD再用)

什么是portainer?

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

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

访问地址:http://ip:808

通过它来访问了:

Docker镜像讲解

镜像是什么

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

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

如何得到镜像:

- 从远程仓库下载
- 朋友拷贝
- 自己制作一个镜DockerFile

Docker镜像加载原理

UnionFS(联合文件系统)

UnionFS(联合文件系统):Union文件系统是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像(没有父镜像)，可以制作各种具体的应用镜像。

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

Docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。

bootfs(boot file system)主要包含bootloader和kernel，bootloader主要是引导加载kernel，Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是boots，这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs(root file system)，在bootfs之上。包含的就是典型Linux系统中的/dev,/proc,/bin,/etc等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如ubuntu,centos等

平时我们安装进虚拟机的centos都是好几个G，为什么Docker这里才200M？

对于一个精简的OS，rootfs可以很小，只需要包含基本的命令，工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就可以了。由此可见对于不同的linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发行版可以公用bootfs.

分层理解

分层的镜像

我们可以去下载一个镜像，注意观察下载的日志输出，可以看到是一层一层的在下载

思考:为什么Docker镜像要采用这种分层的结构呢?

最大的好处，我觉得莫过于是资源共享了，比如有多个镜像都从相同的Base镜像构建而来，那么宿主机只需在磁盘上保留一份base镜像，同时内存中也只需要加载一份base镜像，这样就可以为所有的容器服务了，而且镜像的每一层都可以被共享。

查看镜像分层的方式可以通过docker images inspect命令:

理解:

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

举个例子，加入基于Ubuntu Linux 16.04创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加Python包，就会在基础镜像层之上创建第二个镜像层；如果继续添加一个安全补丁，就会创建第三个镜像层。

该镜像当前已经包含3个镜像层，如图所示(演示)

在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合，理解这点很重要，每个镜像层包含3个文件，而镜像包含了来自两个镜像层的6个文件。

特点

Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部!

这一层就是我们通常说的容器层，容器之下的都叫镜像层!

如何提交一个自己的镜像

commit镜像

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

实战测试

# 1、启动一个默认的tomcat
# 2、发现这个默认的tomcat是没有webapps应用，镜像的原因,官方的镜像默认webapps下面是没有文件的!
# 3、我自己拷贝进去了基本的文件
# 4、将我们操作过的容器通过commit提交为一个镜像!我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像

学习方式说明:理解概念，但是一定要实践，最后实践和理论相结合一次搞定这个知识

如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像

就好比我们以前学习VM时候，快照!

容器数据卷

什么是容器数据卷

docker的理念回顾

将应用和环境打包成一个镜像

数据?如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化

MySQL，容器删除了，删除跑路！需求:MySQL数据可以存储在本地!

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

这就是卷技术！目录的挂载，将我们容器内的目录，挂载到Linux上面!

作用：

卷就是目录或者文件，存在一个或者多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过 Union File System ，提供一些用于持续存储或共享数据的特性：

卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷。

特点：

1、数据卷可在容器之间共享或重用数据

2、卷中的更改可以直接生效

3、数据卷中的更改不会包含在镜像的更新中

4、数据卷的生命周期一直持续到没有容器使用它为止

所以：总结一句话：就是容器的持久化，以及容器间的继承和数据共享！

使用数据卷

方法一:容器中直接使用命令来添加

挂载

# 命令
docker run -it -v 宿主机绝对路径目录:容器内目录   镜像名

#测试
[root@root~]#docker run -it -v /home/kali:/home centos /bin/bash

查看数据卷是否挂载成功 docker inspect 容器id

测试容器和宿主机之间数据共享:可以发现，在容器中，创建的会在宿主机中看到!

测试容器停止退出后，主机修改数据是否同步!

停止容器
在宿主机上修改文件，增加内容
启动刚才停止的容器
然后查看对应的文件，发现数据依旧同步

使用docker安装mysql

思考:mysql数据持久化的问题!

#1、搜索镜像
[root@root~]#docker search mysql

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

#3、启动容器  -e 环境变量!
#注意:mysql的数据应该不丢失!先体验下 -v 挂载卷!参考官方文档
[root@root~]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:5.7

#4、使用本地的sqlyog连接测试一下 3310

#5、查看本地的/home/mysql 目录
[root@root	data]#pwd
/home/mysql/data
[root@root data]#ls
.....test  #可以看到我们刚刚建立的mysql数据库在本地存储着

#6、删除mysql容器
[root@root data]#docker rm -f mysql01 #删除容器，然后发现远程连接失败!
[root@root data]#ls
.... test   #可以看到我们刚刚建立的mysql数据库在本地存储着

通过DockerFile来添加(了解)

DockerFile是用来构建Docker镜像的构建文件，是由一些列命令和参数构成的脚本

我们在这里，先体验下，后面我们会详细讲解DockerFile!

测试:

#1、我们在宿主机  /home 目录下新建一个docker-test-volume文件夹
[root@root home]#mkdir docker-test-volume
#说明:在编写DockerFile文件中使用VOLUME指令来给镜像添加一个或多个数据卷
VOLUME["/dataVolumeContainer1","/dataVolumeContainer2","/dataVolumeContainer3"]
#出于可移植和分享的考虑，我们之前使用的-v   主机目录:容器目录  这种方式不能够直接在DockerFile中实现
#由于宿主机目录是依赖于特定宿主机的，并不能保证在所有宿主机上都存在这样的特定目录

#2、编写DockerFile文件
[root@root docker-test-volume]#pwd
[root@root docker-test-volume]# vim dockerfile1
[root@root docker-test-volume]# cat dockerfile1
# volume test
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "-------end------"
CMD /bin/bash

#3、build后生成镜像，获得一个新镜像 root/centos
docker build -f /home/docker-test-volume/dockerfile1  -t root/centos .  #注意最后面有个.

#4、启动容器
[root@root docker-test-volume]#docker run -it  267374ee3782  /bin/bash #启动容器

#问题:通过上述步骤，容器内的卷目录地址就已经知道了，但是对应的主机目录地址在哪里呢?
#5、我们在数据卷中新建一个文件
[root@root datavolumeContainer1]#pwd
[root@root data]#ls
.... ... ...test  #可以看到我们刚刚建立的mysql数据库在本地存储着

#6、删除mysql容器
[root@root data]#docker rm -f mysql01  #删除容器，然后发现远程连接失败!
[root@root data]#ls
... ... . test  #可以看到我们刚刚建立的mysql数据库在本地存储着

通过Docker File来添加(了解)

DockerFile是用来构建Docker镜像的构建文件，是由一些列命令和参数构成的脚本。

我们在这里，先体验下，后面我们会详细讲解DockerFile!

测试:

#1、我们在宿主机 /home 目录下新建一个docker-test-volume文件夹
[root@root home]#mkdir docker-test-volume
#说明: 在编写DockerFile文件中使用VOLUME指令来给镜像添加一个或多个数据卷
VOLUME["/dataVolumeContainer1","/dataVolumeContainer2","/dataVolumeContainer
3"]
# 出于可移植和分享的考虑，我们之前使用的 -v 主机目录:容器目录 这种方式不能够直接在
DockerFile中实现。
# 由于宿主机目录是依赖于特定宿主机的，并不能够保证在所有宿主机上都存在这样的特定目录.
# 2、编写DockerFile文件
[root@kuangshen docker-test-volume]# pwd
/home/docker-test-volume
[root@kuangshen docker-test-volume]# vim dockerfile1
[root@kuangshen docker-test-volume]# cat dockerfile1
# volume test
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "-------end------"
CMD /bin/bash
# 3、build后生成镜像，获得一个新镜像 kuangshen/centos
docker build -f /home/docker-test-volume/dockerfile1 -t kuangshen/centos . #主义最后有个.

# 4、启动容器
[root@root docker-test-volume]#docker run -it 0e97e1891a3d  /bin/bash
[root@root /]#ls -l

# 问题:通过上述步骤，容器内的卷目录地址就已经知道了，但是对应的主机目录地址在哪里呢？
# 5、我们在数据卷中新建一个文件
[root@f5824970eefc dataVolumeContainer1]# pwd
/dataVolumeContainer1
[root@f5824970eefc dataVolumeContainer1]# touch container.txt
[root@f5824970eefc dataVolumeContainer1]# ls -l
total 0
-rw-r--r-- 1 root root 0 May 11 11:58 container.txt
# 6、查看下这个容器的信息
[root@kuangshen ~]# docker inspect 0e97e1891a3d
# 查看输出的Volumes
"Volumes": {
"/dataVolumeContainer1": {},
"/dataVolumeContainer2": {}
},
# 7、这个卷在主机对应的默认位置

注意：如果访问出现了 cannot open directory: Permission denied

解决办法：在挂载目录后多加一个 --privileged=true参数即可

匿名和具名挂载

#匿名挂载
-v 容器内路径
docker run -d -P --name nginx01 -v /etc/nginx nginx
#匿名挂载的缺点，就是不好维护，通常使用命令docker volume维护
docker volume ls

#具名挂载
-v 卷名:/容器内路径
docker run -d -P --name nginx02 -v nginxconfig:/etc/nginx nginx

#查看挂载的路径
[root@root ~]docker volume inspect nginxconfig
#改变文件的读写权限
# ro: readonly
# rw:readwrite
#指定容器对我们挂载出来的内容的读写权限
docker run -d -P --name nginx02 -v nginxconfig:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v nginxconfig:/etc/nginx:rw nginx

数据卷容器

命名的容器挂载数据卷，其他容器通过挂载这个(父容器)实现数据共享，挂载数据卷的容器，称之为数据卷容器。

我们使用上一步的镜像:kuangshen/centos为模板，运行容器docker01，docker02，docker03，他们都会具有容器卷

"/dataVolumeContainer1"
"/dataVolumeContainer2"

我们来测试下，容器间传递共享

1、先启动一个父容器docker01，然后在dataVolumeContainer2新增文件

退出不停止:ctrl+P+Q

2、创建docker02，docker03让他们继承docker01 --volumes-from

[root@VM-8-7-centos ~]# docker run -it --name docker02 --volumes-from docker01 kuangshen/centos
[root@f17d32fb0dd5 /]# cd ./volume02
[root@f17d32fb0dd5 volume02]# ls
[root@f17d32fb0dd5 volume02]# touch docker02.txt
[root@f17d32fb0dd5 volume02]# ls
docker02.txt
[root@VM-8-7-centos ~]# docker run -it --name docker03 --volumes-from docker01 kuangshen/centos
[root@ca65c4ab6e31 /]# ls
bin  etc   lib    lost+found  mnt  proc  run   srv  tmp  var       volume02
dev  home  lib64  media       opt  root  sbin  sys  usr  volume01
[root@ca65c4ab6e31 /]# cd ./volume02
[root@ca65c4ab6e31 volume02]# ls
docker02.txt
[root@ca65c4ab6e31 volume02]# touch docker03.txt
[root@ca65c4ab6e31 volume02]# ls
docker02.txt  docker03.txt

3、回到docker01发现可以看到02和03添加的共享文件

[root@VM-8-7-centos ~]# docker attach docker01
[root@9138694dc9f8 volume01]# ls
docker01.txt
[root@9138694dc9f8 volume01]# cd ..
[root@9138694dc9f8 /]# ls
bin  etc   lib    lost+found  mnt  proc  run   srv  tmp  var       volume02
dev  home  lib64  media       opt  root  sbin  sys  usr  volume01
[root@9138694dc9f8 /]# cd ./volume02
[root@9138694dc9f8 volume02]# ls -l
total 0
-rw-r--r-- 1 root root 0 May 29 10:03 docker02.txt
-rw-r--r-- 1 root root 0 May 29 10:13 docker03.txt

4、删除docker01，docker02修改后docker03还能不能访问

[root@VM-8-7-centos ~]# docker rm -f docker01
docker01
[root@VM-8-7-centos ~]# docker attach docker02
[root@f17d32fb0dd5 volume02]# ls -l
total 0
-rw-r--r-- 1 root root 0 May 29 10:03 docker02.txt
-rw-r--r-- 1 root root 0 May 29 10:13 docker03.txt

[root@f17d32fb0dd5 volume02]# touch docker02-update.txt
[root@f17d32fb0dd5 volume02]# ls -a
.  ..  docker02-update.txt  docker02.txt  docker03.txt
[root@VM-8-7-centos ~]# docker attach docker03
[root@ca65c4ab6e31 volume02]# ls -l
total 0
-rw-r--r-- 1 root root 0 May 29 10:21 docker02-update.txt
-rw-r--r-- 1 root root 0 May 29 10:03 docker02.txt
-rw-r--r-- 1 root root 0 May 29 10:13 docker03.txt
[root@ca65c4ab6e31 volume02]##ctrl+p+q  退出容器
[root@VM-8-7-centos ~]# docker attach docker03
[root@ca65c4ab6e31 volume02]# ls -l
total 0
-rw-r--r-- 1 root root 0 May 29 10:21 docker02-update.txt
-rw-r--r-- 1 root root 0 May 29 10:03 docker02.txt
-rw-r--r-- 1 root root 0 May 29 10:13 docker03.txt

5、删除docker02，docker03还能不能访问

[root@VM-8-7-centos ~]# docker ps
CONTAINER ID   IMAGE              COMMAND                  CREATED          STATUS          PORTS     NAMES
ca65c4ab6e31   kuangshen/centos   "/bin/sh -c /bin/bash"   13 minutes ago   Up 13 minutes             docker03
f17d32fb0dd5   kuangshen/centos   "/bin/sh -c /bin/bash"   24 minutes ago   Up 24 minutes             docker02
[root@VM-8-7-centos ~]# docker rm -f docker02
docker02
[root@VM-8-7-centos ~]# docker attach docker03
[root@ca65c4ab6e31 volume02]# ls
docker02-update.txt  docker02.txt  docker03.txt
[root@ca65c4ab6e31 volume02]# touch docker03-update.txt
[root@ca65c4ab6e31 volume02]# ls
docker02-update.txt  docker02.txt  docker03-update.txt  docker03.txt

6、新建docker04继承docker03，然后再删除docker03，看下是否可以访问!


[root@bc53ab11bc9f /]# cd ./volume02
[root@bc53ab11bc9f volume02]# ls -l
total 0
-rw-r--r-- 1 root root 0 May 29 10:21 docker02-update.txt
-rw-r--r-- 1 root root 0 May 29 10:03 docker02.txt
-rw-r--r-- 1 root root 0 May 29 10:29 docker03-update.txt
-rw-r--r-- 1 root root 0 May 29 10:13 docker03.txt

#查看当前运行的容器
[root@VM-8-7-centos ~]# docker ps
CONTAINER ID   IMAGE              COMMAND                  CREATED          STATUS          PORTS     NAMES
bc53ab11bc9f   kuangshen/centos   "/bin/sh -c /bin/bash"   2 minutes ago    Up 2 minutes              docker04
ca65c4ab6e31   kuangshen/centos   "/bin/sh -c /bin/bash"   20 minutes ago   Up 20 minutes             docker03

#继续删除docker03
[root@VM-8-7-centos ~]# docker attach docker04
[root@bc53ab11bc9f volume02]# ls -l
total 0
-rw-r--r-- 1 root root 0 May 29 10:21 docker02-update.txt
-rw-r--r-- 1 root root 0 May 29 10:03 docker02.txt
-rw-r--r-- 1 root root 0 May 29 10:29 docker03-update.txt
-rw-r--r-- 1 root root 0 May 29 10:13 docker03.txt

得出结论:

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

存储在本机的文件则会一直保留!

DockerFile

大家想想,Nginx,tomcat,mysql这些镜像都是哪里来的?官方能写，我们不能写吗?

我们要研究部自己如何做一个镜像，而且我们写的微服务项目以及springboot打包上云部署，Docker就是最方便的。

微服务打包成镜像，任何装了Docker的地方，都可以下载使用，极其的方便。

流程:开发应用=>DockerFile=>打包为镜像=>上传仓库(私有仓库，公有仓库) =>下载镜像 =>启动运行。

还可以方便移植!

什么是DockerFile

dockerfile是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本。

构建步骤:

1、编写DockerFile文件

2、docker build构建镜像

3、docker run

dockerfile文件我们刚才已经编写过了一次，这里我们继续使用centos来看!

地址:Docker Hub

DockerFile构建过程

基础知识:

1、每条保留字指令都必须为大写字母且后面要跟随至少一个参数

2、指令按照从上到下，顺序指令

3、#表示注释

4、每条指令都会创建一个新的镜像层，并对镜像进行提交

流程:

1、docker从基础镜像运行一个容器

2、执行一条指令并对容器做出修改

3、执行类似docker commit的操作提交一个新的镜像层

4、Docker再基于刚提交的镜像运行一个新容器

5、执行dockerfile中的下一条指令直到所有指令都执行完成!

说明:

从应用软件的角度来看，DockerFile,docker镜像与docker容器分别代表软件的三个不同阶段。

DockerFile是软件的原材料(代码)
Docker镜像则是软件的交付品(.apk)
Docker容器则是软件的运行状态(客户下载安装执行)

DockerFile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署于运维，三者缺一不可!

DockerFile:需要定义一个DockerFile、DockerFile定义了进程需要的一切东西。DockerFile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当引用进行需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的版权控制)等等。

Docker镜像:在DockerFile定义了一个文件之后，Docker build时会产生一个Docker镜像，当运行Docker镜像时，会真正开始提供服务;

Docker容器:容器是直接提供服务的。

DockerFile指令

关键字:

FROM			#基础镜像，当前新镜像时基于哪个镜像的
MAINTAINER		#镜像维护者的姓名混合邮箱地址
RUN				#容器构建时需要运行的命令
EXPOSE			#当前容器对外保留出的端口
WORKDIR			#指定在创建容器后，终端默认登录的进来工作目录，一个落脚点
ENV				#用来在构建镜像过程中设置环境变量
ADD				#将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
COPY			#类似ADD，拷贝文件和目录到镜像中!
VOLUME			#容器数据卷，用于数据保存和持久化工作
CMD				#指定一个容器启动时要运行的命令，dockerFile中可以有多个CMD指令，但只有最后一个生效！
ENTRYPOINT		#指定一个容器启动时要运行的命令!和CMD一样
ONBUILD			#当构建一个被继承的DockerFile时运行命令，父镜像在被子镜像继承后，父镜像的ONBUILD被触发

实战测试

Docker Hub中99%的镜像都是通过在base镜像(Scratch)中安装和配置需要的软件构建出来的

自定义一个centos

1、编写DockerFile

查看下官方默认的CentOS的情况:

目的:使我们自己的镜像具备如下:登录后的默认路径、vim编辑器、查看网络配置ifconfig支持

准备编写DockerFile文件

[root@VM-8-7-centos home]# mkdir dockerfile-test
[root@VM-8-7-centos home]# ls
dockerfile-test     kali        mysql  test.java
docker-test-volume  lighthouse  test   www
[root@VM-8-7-centos home]# vim mydockerfile-centos
[root@VM-8-7-centos home]# cat mydockerfile-centos
FROM centos
MAINTAINER kali<3027532658@qq.com>

ENV MYPATH  /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "------end------"
CMD /bin/bash
[root@VM-8-7-centos home]#

2、构建

docker build -f dockerfile地址 -t 新镜像名字:TAG .

会看到docker build 命令最后有一个. .表示当前目录

[root@VM-8-7-centos home]# docker build -f mydockerfile-centos -t mycentos:1.1 .
Sending build context to Docker daemon  207.2MB
Step 1/10 : FROM centos
 ---> 5d0da3dc9764
Step 2/10 : MAINTAINER kali<3027532658@qq.com>
 ---> Using cache
 ---> f8f6ce21d4ca
Step 3/10 : ENV MYPATH  /usr/local
 ---> Using cache
 ---> 78f3126f62d6
Step 4/10 : WORKDIR $MYPATH
 ---> Using cache
 ---> b561ac324906
Step 5/10 : RUN yum -y install vim
 ---> Running in d3b2bcbde1df
CentOS Linux 8 - AppStream

3、运行

docker run -it 新镜像名字:TAG

可以看到，我们自己的镜像已经支持vim/ifconfig的命令，扩展ok!

4、列出镜像地变更历史

docker history 镜像名

CMD和ENTRYPOINT的区别

我们之前说过，两个命令都是指定一个容器启动时要运行的命令

CMD: Dockerfile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run 之后的参数替换!

ENTRYPOINT: docker run之后的参数会被当做参数传递给ENTRYPOINT，之后形成新的命令组合!

测试:

CMD命令

#1、构建dockerfile
[root@VM-8-7-centos home]# vim dockerfile-cmd-test
[root@VM-8-7-centos home]# cat dockerfile-cmd-test
FROM centos
CMD [ "ls","-a"]

#2、build镜像
[root@VM-8-7-centos home]# docker build -f dockerfile-cmd-test  -t cmdtest .
Sending build context to Docker daemon  207.2MB
Step 1/2 : FROM centos
 ---> 5d0da3dc9764
Step 2/2 : CMD [ "ls","-a"]
 ---> Running in 0de5a1e75e7e
Removing intermediate container 0de5a1e75e7e
 ---> 307368b0a374
Successfully built 307368b0a374
Successfully tagged cmdtest:latest
#3、执行

[root@VM-8-7-centos home]# docker run  307368b0a374
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
lost+found
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
.....

#4、如果我们希望用-l列表展示信息，我们就需要加上  -l参数
[root@VM-8-7-centos home]# docker run cmdtest -l
docker: Error response from daemon: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "-l": executable file not found in $PATH: unknown.

#问题:我们可以看到可执行文件找不到的报错，executable file not found 。
#之前我们说过,跟着镜像名后面的是command,运行时会替换CMD的默认值。
#因此这里的-l替换了原来的CMD，而不是添加在原来的ls -a后面。而-l根本不是命令，所以自然找不到。
#那么如果我们希望加入-l这个参数，我们就必须重新完整的输入这个命令:
docker run cmdtest ls -al

ENTRYPOINT命令

#1、构建dockerfile

[root@VM-8-7-centos home]# vim dockerfile-entrypoint-test
[root@VM-8-7-centos home]# cat dockerfile-entrypoint-test
FROM centos
ENTRYPOINT [ "ls","-a" ]

#2、build镜像
[root@VM-8-7-centos home]# docker build -f dockerfile-entrypoint-test  -t entrypointtest .
Sending build context to Docker daemon  207.2MB
Step 1/2 : FROM centos
 ---> 5d0da3dc9764
Step 2/2 : ENTRYPOINT [ "ls","-a" ]
 ---> Running in 1baa5dadc078
Removing intermediate container 1baa5dadc078
 ---> b431b37e3fef
Successfully built b431b37e3fef
Successfully tagged entrypointtest:latest

#3、执行
[root@VM-8-7-centos home]# docker run  b431b37e3fef
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
......

#4、测试-l参数，发现可以直接使用，这里就是一种追加，我们可以明显的知道CMD 和 ENTRYPOINT的区别了
[root@VM-8-7-centos home]# docker run entrypointtest -l
total 56
drwxr-xr-x   1 root root 4096 May 30 12:10 .
drwxr-xr-x   1 root root 4096 May 30 12:10 ..
-rwxr-xr-x   1 root root    0 May 30 12:10 .dockerenv
lrwxrwxrwx   1 root root    7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x   5 root root  340 May 30 12:10 dev
drwxr-xr-x   1 root root 4096 May 30 12:10 etc
drwxr-xr-x   2 root root 4096 Nov  3  2020 home
lrwxrwxrwx   1 root root    7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx   1 root root    9 Nov  3  2020 lib64 -> usr/lib64
drwx------   2 root root 4096 Sep 15  2021 lost+found

自定义镜像tomcat

mkdir -p kali/build/tomcat
在上述目录下touch read.txt
将JDK和tomcat安装的压缩包拷贝进上一步目录
在/kali/build/tomcat目录下新建一个Dockerfile文件

# vim  Dockerfile

FROM centos
MAINTAINER kali<3027532658@qq.com>
#把宿主机当前上下文的read.txt拷贝到容器/usr/local 路径下
COPY read.txt /usr/local
WORKDIR	$MYPATH
#配置java与tomcat环境变量
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.22
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.22
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE 8080
#启动时运行tomcat
# ENTRYPOINT ["/usr/local/apache-tomcat-9.0.22/bin/startup.sh" ]
# CMD ["/usr/local/apache-tomcat-9.0.22/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-9.0.22/bin/startup.sh && tail -F
/usr/local/apache-tomcat-9.0.22/bin/logs/catalina.out

posted @ 2022-06-05 20:16 kalibb 阅读(173) 评论(0) 收藏举报

刷新页面返回顶部

flag

Docker

Docker

Docker概述

Docker为什么会出现

Docker能干嘛

Docker安装

Docker的基本组成

环境说明

安装步骤

底层原理

Docker常用命令

帮助命令

镜像命令

容器命令

常用的其它命令

作业练习

可视化

Docker镜像讲解

镜像是什么

Docker镜像加载原理

分层理解

commit镜像

容器数据卷

什么是容器数据卷

使用数据卷

匿名和具名挂载

数据卷容器

DockerFile

什么是DockerFile

DockerFile构建过程

DockerFile指令

实战测试

公告