大家好，又见面了，我是全栈君。

Docker核心技术

文章目录

Docker核心技术

思维导图： http://naotu.baidu.com/file/85634842b0e8e8630651d0fc5bf5b9a4

一、Docker简介

问题：为什么会出现docker呢？

场景：1、“在我机器上可以正常工作”问题。因为环境和配置不同，开发和运维会出现运行结果。

2、多台机器上需要部署一套代码（集群）。每一台都进行一次安装操作，过程繁琐耗时。

开发 | 运维

代码—> war | 部署

解答：安装的时候，把原始环境一模一样的复制，开发和运维的环境和配置一样（不需要重新安装环境和更改配置）！

平台耦合性

你今天的优势会被明天的趋势所取代！

买书容易，看书难，搬家还麻烦！

二、Docker安装

前提说明

1、 CentOs Docker 安装

Docker 支持一下的CentOs版本：

CentOS 7 （64 bit）
CentOS 6.5 （64 bit）或者更高版本

2、前提条件

目前，CentOS仅发行版本中内核支持Docker。

Docker运行在CentOS 7上，要求系统为64位，系统内核为3.10+！

Docker运行在CentOS6.5或者更高版本的CentOS上，要求系统为64位，系统内核版本为2.6.32-431或者更高。

3、查看自己的内核

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

# uname -r

查看安装CentOS版本信息

# lsb_release -a
# cat /etc/readhat-release

Docker 的基本组成

几张图帮你理解 docker 基本原理及快速入门

Docker构架

1、镜像（Image）

Docker镜像就是一个只读的模板。镜像可以用来创建Docker容器，一个镜像可以创建很多容器。

Docker	面向对象
容器	对象
镜像	类

2、容器（container）

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

它可以被启动、开始、停止、删除。每个容器都是互相隔离的、保证安全的平台。可以把容器看做是一个简易版的Linux环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。

3、仓库（Repository）

仓库是集中存放镜像文件的场所。仓库和仓库注册服务器（Registry）是有区别的。仓库注册服务器上往往存放着多个仓库，每个仓库包含多个镜像，每个镜像有不同的标签（Tag）。

仓库分为：公开仓库（Public）和私有仓库（Private）

最大的公开仓库是 Docker Hub：https://hub.docker.com/

存在放数量庞大的镜像提供用户下载。国内公开的仓库有阿里云、网易云等。

4、总结

安装

配置镜像加速，配置的时候CentOS 6.8和 7配置文件不同。

Docker 安装
 Docker 安装清华

配置镜像加速：

# 阿里云
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{ 
   
  "registry-mirrors": ["https://n7alqmf2.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

# 网易云
{ 
   
  "registry-mirrors": ["http://hub-mirror.c.163.com"]
}

centos 7 安装docker

1、官网中文安装手册

2、确定你是centos7及以上版本
cat /etc/redhat-release

3、yum安装gcc相关
yum -y install gcc
yum -y install gcc-c++
gcc  -v

4、卸载旧的docker版本

5、安装需要的软件包

6、设置stable 镜像仓库
# 大坑
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
报错：
Errno 14 ： TCP connection reset by peer
Errno 12 ： Timeout
# 推荐
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
7、更新yum 软件包索引
yum makecache fast

8、安装docker ce
yum -y install docker-ce

9、启动docker
systemctl start docker

10、测试 
docker version
docker run  hello-world

11、配置进行加速配置
(1)、mkdir -p /etc/docker
(2)、vim /etc/docker/daemon.json
#### 网易云
{ 
   "registry-mirrors":["http://hub-mirror.c.163.com"]}

#### 阿里云
{ 
   "registry-mirrors":["http://{自己的编码}.mirror.aliyuncs.com"]}
# dufy aliyun
{ 
   
  "registry-mirrors": ["https://n7alqmf2.mirror.aliyuncs.com"]
}

(3)、systemctl daemon-reload
(4)、systemctl restart docker

12、停止docker服务
systemctl stop docker
13、卸载
yum -y remove docker-ce
rm -rf /var/lib/docker

启动hello-world

docker run hello-world ，先从本地找，如果本地不存在，则会从远程的仓库中镜像pull 操作。（下载镜像）

run 启动容器。

Docker核心技术学习笔记

底层原理

1、Docker是怎么工作的？

2、Docker为什么比VM快？

三、Docker常用命令

帮助命令

docker  version ： docker版本

docker info ： docker详细信息描述

docker --help ： docker 的帮助命令

镜像命令

1、docker images

列出本地主机上的镜像

REPOSITORY	TAG	IMAGE ID	CREATED	SIZE
表示镜像的仓库	镜像的标签	镜像ID	镜像创建时间	镜像大小

同一个仓库源可以有多个TAG，代表这个仓库源的不同个版本，使用REPOSITORY:TAG来定义不同的镜像。如果不指定一个镜像的版本标签，例如使用Ubuntu，Docker默认使用ubuntu:latest镜像。

参数说明：

-a ：列出本地所有的镜像（含中间映射层

-q ：只显示镜像ID

–digests ：显示镜像的摘要信息

–no-trunc ：显示完整的镜像信息

2、docker search XXX 某个镜像的名字

网站：https://hub.docker.com/

命令：docker search 【options】镜像名字

-s ：列出收藏数不小于指定值的镜像，docker search -s 30 tomcat

–no-trunc ：显示完整镜像描述

–automated ：只列出 automated bulid 类型的镜像

3、docker pull 镜像名

docker pull tomcat == docker pull tomcat[: TAG] ，默认TAG为latest

4、docker rmi 镜像名字/镜像ID – 删除镜像

强制删除：-f

删除单个：docker rmi -f hello-world

删除多个：docker rmi -f hello-world nginx

删除全部：docker rmi -f $(docker images -qa)

?? 思考：结合git的学习心得，可以猜测docker 会有 docker commit /docker push?

容器命令

前提：有镜像才能创建容器

1、新建并启动容器

# docker run [options] image [command] [arg...]
options说明:有些是一个减号，有些是两个减号
--name="容器新名字" ： 为容器指定一个名称
-d ： 后台运行容器，并返回容器的ID，也即启动守护式容器
-i ： 以交互模式运行容器，通常与 -t 同时使用  [重要]
-t ： 为容器重新分配一个伪输入终端，通常与 -i 一起使用  [重要]
-P ： （大写）随机端口映射
-p ： （小写）指定端口映射，有以下四种格式
	ip:hostPort:containerPort
	ip::containerPort
	hostPort:containerPort [重要]
	containerPort

2、列出当前所有正在运行的容器

docker ps  [-a]
-a ： 代表 所有容器，包括运行和非运行的容器。
-l ： 显示最近创建的容器
-n ： 显示最近n个创建的容器
-q ： 静默模式，只显示容器编号
--no-trunc : 不截断显示

3、容器的退出、启停

# 退出交互终端
exit ： 容器停止退出
ctrl+P+Q ： 容器不停止退出
# 启动
docker start container-name/container-id

# 重启
docker restart container-name/container-id

# 停止
docker stop container-name/container-id

# 强制停止
docker kill container-name/container-id

4、容器的删除

# 删除一个
docker rm container-id
-f ： 强制删除

# 删除多个
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm # 上一个参数的结果集传递给下一个参数

6、重要

（1）、启动守护式容器

docker run -d 容器名

注意：使用后台模式启动一个镜像，使用docker ps -a 查看，发现容器已经退出。
很重要的一点说明：Docker 容器后台运行，就必须有一个前台进程。
容器运行的命令如果不是那些一直挂起的命令（如 top、tail）等，就是会自动退出的。

这个是Docker的机制问题，比如你的web容器，我们以nginx 为例，正常情况下，我们配置启动服务只需要启动响应的Service即可。例如 service nginx start。但是，这样做，nginx为后台进行模式运行，就导致docker 前台没有运行的应用，这样的容器后台启动后，会立即自杀。因为他觉得他没事可做了。

所以，最佳的解决方案是： 将你要运行的程序以前台进程的形式运行。

例子：
docker run -d /bin/bash -c "while true;do echo hello centos;sleep 2;done"

（2）、查看容器日志

docker logs -f -t --tail 容器id
-t：加入的时间戳
-f：跟随最新的日志打印
--tail：数字显示最后多少条

(3)、查看容器内运行的进程

docker top 容器id

（4）、查看容器内部细节

# docker 镜像是一层套一层
docker inspect 容器id

（5）、进入正在运行的容器并以命令行交互

# docker exec -it 容器id bashShell
docker exec -t 3d51887b06b6  ls -l /tmp

docker exec -t 3d51887b06b6 /bin/bash

# 重新进入docker attach 容器id
docker attach 3d51887b06b6
上述两个区别：
- attach：直接进入容器启动命令的终端，不会启动新的进程
- exec：在容器中打开新的终端，并可以启动新的进程

（6）、从容器内拷贝文件到主机上

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

总结

Docker event state

不懂原理，你就是一个API调用工程师！

docker全部的命令 : http://www.runoob.com/docker/docker-command-manual.html

四、Docker 镜像

Docker 镜像就是一个千层饼，一层套一层。

1、镜像是什么？

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

UnionFS（联合文件系统）

UnionFS

Docker镜像加载原理

Docker镜像加载原理

分层的镜像

以pull 为例，一层一层的往下拉取。

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

最大的好处就是 – 共享资源。比如：有对个镜像都从相同的 base 进行构建而来，那么宿主机只需在磁盘上保存一份base镜像，同时内存中也只需加载一份base镜像，就可以为所有的容器服务了。而且镜像的每一层都可以被共享。

Docker核心技术学习笔记

问题1：tomcat为什么那么大400多M？

实际上有多层文件构成，一层一层进行打包。

2、镜像特点

Docker 镜像都是只读的（类似鸡蛋- 蛋壳-》蛋清-》蛋黄），当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作 “容器层” ，“容器层”之下都叫 “镜像层”。

3、Docker镜像commit操作补充

（1）、docker commit

# docker commit 提交容器副本使之成为一个新的镜像。

docker commit -m="提交的描述信息" -a="作者" 容器id 要创建的目标镜像名:[标签名]

# 案例演示
1、启动tomcat镜像 ，-p 8888代表是 docker的端口，8080 docker中 是tomcat的端口。
docker run -p 8888:8080 tomcat
-p：指定端口映射
-P：随机端口映射

2、故意删除tomcat容器的文档

3、把没有文档的tomcat容器当作一个模板，提交commit

4、启动新镜像 和 原来对比

4 、镜像生成的途径

Docker核心技术学习笔记

5、镜像导入导出

Docker核心技术学习笔记

一次打包可以打包多个镜像。

docker save -o tomcatimage.gz dufy/tomcat:v0.9 dufy/tomcat:v1.0

docker load -i tomcatimage.gz

6、镜像推送到仓库

推送Docker hub、推送到阿里云，需要进行登录。dokcer login 、 docker logout

五、Docker容器数据卷

1、是什么

简单的说就是将Docker容器运行的一些数据结果保存起来（持久化+共享）。类似redis中的RDB和AOF。

Docker理念：

将应用与运行的环境打包形成容器运行，运行可以伴随着容器，但是我们对数据的要求希望是持久化的
容器之间希望有可能共享数据

Docker 容器产生的数据，如果不通过docker commit 生成新的镜像，使得数据作为镜像的一部分保存下来，那么容器删除之后，数据自然也就没有了。

为了能保存数据在docker 中，我们使用数据卷。

2、能干嘛

容器产生数据的持久化
容器间继承 + 共享数据
容器到主机，主机到容器之间的数据共享

3、数据卷

（1）直接命令添加

注意：数据卷的目录地址不能映射容器应用一样的目录名！

例如： tomcat /usr/local/tomcat/conf ，这个配置文件的目录不能进行映射。

# 添加命令 如果有Permission denied ，加 --privileged=true
1、docker run -it -v /容器内目录 镜像名 # 此种方式会自动在宿主机中生成一个对应绑定的目录
2、docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名

例子： docker run -it -v /myDataVolume:/dataVloumeContainer centos
-v ： 主机和容器之间数据共享

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

# 容器和宿主机之间数据共享

# 容器停止退出后，主机修改后数据是否同步
容器 exit，主机修改文件后，容器启动后，数据可以进行同步。

# 命令（带权限）写保护，
docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名
- ro ： read only ,容器只可以读，不可写。

（2）、DockerFile添加

DockerFile : 镜像 –》DockerFile , 描述Docker的文件。

JavaEE : Hello.java —》Hello.class

# 1、根目录下新建一个myDocker 文件夹并进入
mkdir myDcker
# 2、可以在Dockerfile 中使用 VOLUME指令 来给镜像添加一个或多个数据卷
VOLUME["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]
说明：
	出于可移植和分享的考虑，用 -v 主机目录:容器目录 这种方法不能够直接在Dockerfile中实现。
	由于宿主机目录是依赖于特定宿主机的，并不能保证所有的宿主机上都存在这样特定目录。

# 3、File构建
vim Dockerfile
---------------------------------------------------------------
# volume test
FROM centos
VOLUME ["/dataVolumeContainer","/dataVolumeContainer2"]
CMD echo "finished ..."
CMD /bin/bash
---------------------------------------------------------------

# 4、bulid后生成镜像--》 获得一个新镜像 newcentos
docker bulid -f /mydocker/Dockerfile -t newcentos/centos .

-f: dockerFile 的意思,dockerfile 文件的目录地址

# 5、run容器
docker run -it newcentos/centos


通过上述步骤，容器内的卷目录地址已经知道，对应的主机目录地址在哪呢？？
-- 
docker inspet 容器id ，查看默认的docker分配的宿主机目录  # 主机上会生成对应默认地址

（3）、备注

Docker 挂载主机目录Docker访问出现 cannot open directory ： Permission denied。

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

4、数据容器卷

（1）是什么？

命名的容器挂载数据卷，其他容器通过挂载这个（父容器）实现数据共享，挂载数据卷的容器，称之为数据卷容器。（活动硬盘挂活动硬盘，实现数据传递共享）

（2）总体介绍

根据上面学习的构建好的newcentos镜像为模板，并运行容器 dc01/dc02/dc03

运行的容器都具有容器卷 [“/dataVolumeContainer”,”/dataVolumeContainer2″] 。

（3）容器间传递共享（–volumes-from）

# 1、先启动一个父容器dc01 ,在 dataVolumeContainer2 中新增内容
docker run -it --name dc01 newcentos/centos
cd /dataVolumeContainer2 
touch dco1.txt

# 2、dc02/dc03继承自dc01 ，使用--volumes-from ，使用同一个网络 --network:container:容器名称
docker run -it --name dc02 --volumes-from dc01 newcentos/centos
cd /dataVolumeContainer2 
ll
>  dco1.txt
touch dco2.txt

docker run -it --name dc03 --volumes-from dc01 newcentos/centos
ll
>  dco1.txt
>  dco2.txt
touch dco3.txt

# 3、回到dc01可以看到02/03各自添加的都能共享
三个实现传递和共享
# 4、删除dc01，dc02修改后dc03可否访问
docker rm -f dc01
dco1.txt 是否还在？
> 还在！

docker attach dc02
touch dco2_update.txt

docker attach dc03
ll
> 也可以实现dc02和dc03之间数据共享
# 5、删除dc02后dc03可否访问

# 6、新建dc04 继承dc03 后，再删除dc03

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

六、DockerFile解析

1、是什么

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

构建三步骤：

1、手动编写一个dockerfile文件，符合file的规范

2、进行bulid执行，获得一个自定义的镜像

3、进行run，启动这个自定义的镜像的容器

文件是什么样？

 # 来自哪里
FROM scratch 
# 
ADD centos-7-docker.tar.xz / 
# 标签
LABEL org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20181006"

# Default command
CMD ["/bin/bash"]

2、DockerFile构建过程解析

（1） dockerfile内容基础知识

每条保留字指令都必须为大写字母（最好大写）且后面要跟随至少一个参数，参数和保留字直接要有空格
指令按照从上到下，顺序执行
‘#’ 表示注释
第一个非注释行，必须是FROM 开始
每条指令都会创建一个新的镜像层，并对镜像镜像提交
要有工作目录，Dockerfile文件名首字母必须大写，所有依赖的包，也必须放入工作目录，或者工作目录的子目录，一定不能是工作目录的父目录。
支持在工作目录中创建一个 .dockeringore,在打包时候不包含配置的文件列表，类似git的ingore

（2）Docker执行Dockerfile的大致流程

1、docker 从基础镜像运行一个容器
2、执行一条指令并对容器作出修改
3、执行类似docker commit的操作提交一个新的镜像层
4、docker 在基于刚提交的镜像运行一个新容器
5、执行Dockerfile中的下一条指令直到所有指令都执行完成

（3）小总结

Docker核心技术学习笔记

3、DockerFile体系结构(保留字指令)

FORM ：指定基准镜像，当前新的镜像是基于哪个镜像的，可以是任何可以用的镜像。默认情况在本地主机上查找，若不存在，这会从Docker hub Registry 上拉取。

Docker核心技术学习笔记

MAINTAINER：作者和作者的邮箱，最新版本废弃，使用下面的LABEL 指令

Docker核心技术学习笔记

LABEL 指定各种各样的元数据。

Docker核心技术学习笔记

RUN ：容器构建时候需要的命令

run中执行的命令必须是基础镜像中有的命令！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tnjGEIyi-1575196281141)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112249_700.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y5M9Tnyp-1575196281142)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112232_995.png)]

EXPOSE ：暴露容器对外服务的端口号，默认协议就是tcp

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fux2JLj8-1575196281143)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112200_344.png)]

WORKKDIR ：指定在创建容器后，终端默认登录的进来工作目录，一个落脚点
ENV ：用来在构件镜像过程中设置环境变量

ENV key value

$key 或者 ${key} ${key:-hello} ${key:+heloo}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pxnQTNKN-1575196281144)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112209_725.png)]

ADD ：将宿主机目录下的文件拷贝进镜像且 ADD命令会自动处理URL和解压tar压缩包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5TvF4Y6q-1575196281147)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112156_707.png)]

COPY：类似ADD，拷贝文件和目录到镜像中。 COPY src dest / COPY [“src”,“dest”]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-14jZuVxY-1575196281149)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112022_133.png)]

VOLUME：容器数据卷，用于数据保存和持久化工作，创建的时候自动创建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TvmsSIin-1575196281150)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112153_948.png)]

CMD ：指定一个容器启动时要运行的命令；Dockerfile中可以有多个CMD指令，但只有最后一个生效。CMD会被docker run 之后的参数替换

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-POup9sn0-1575196281151)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112248_774.png)]

ENTRYPOINT：指定一个容器启动时要运行的命令；ENTRYPOINT目的和CMD一样，都是在指定容器启动程序及参数，ENTRYPOINT会被 docker run 之后的追加！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QJaUrOIS-1575196281151)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112309_288.png)]

ONBUILD：当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbulid被触发
USER : 指定容器运行中的用户名或者UID

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rej0fLOd-1575196281152)(http://dufyun.gitee.io/images_bed/images/qiniu/201811122248_317.png)]

healthCHeck ：检查主进线的健康状态，可设定检查的时间
SHELL : 默认是[“bin/sh”,”-c”] ，运行程序默认执行，知道即可。
STOPSIGNAl：　停止信号，知道即可。
ARG : build 的时候使用。–docker build –build-arg
保留字运行的阶段

DockerFile

4、案例

运用知识的能力，执行力！

4.1 Base镜像（scratch）

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

4.2 自定义镜像

1、编写
- Hub上默认centos的情况
- 准备编写DockerFile文件
- myCentos内容DockerFile

#1、初始 centos 运行该镜像 进入时候默认路径是 / 
#2、默认不支持 vim
#3、默认不支持 ifconfig

自定义mycentos ，使得我们自己的镜像具备如下：
 登录后修改默认路径
 vim 编辑器
 查看网络配置ifconfig支持
 
------

from centos
env mypath /tmp
workdir $mypath

run yum -y install vim
run yum -y install net-tools

expose 80

cmd echo $mypath
cmd echo "success..."
cmd /bin/bash
 
------
新建dockerfile文件

2、构建

docker build -f dockerfile文件目录 -t 新镜像名字:TAG .

-t ：打标签，仓库名：标签

注意 . ,当前目录。

3、运行

docker run -it mycentos:tag

4、列出镜像的变更历史

docker history 镜像ID

4.3 CMD/ENTRYPOINT 镜像案例

都是指定一个容器启动时要运行的命令。CMD会替换最后运行的参数。ENTRYPOINT不会替换，进行追加（新的命令组合）。

# tocmat 演示 CMD 
CMD ["catalina.sh","run"]
docker run -p 7777:8080 tomcat ls -l
# 这个时候tomcat不会自动启动tomcat

-------------------------------------

FROM centos
RUN yum install -y curl
CMD ["curl","s","http://ip.cn"]

想看 请求头 curl -i

制作ENTRYPOINT 版本的IP信息查询容器
FORM centos
RUN  yum -y install curl
ENTRYPOINT ["curl","-s","http://ip.cn"]

# onbuild 案例
FORM centos
RUN  yum -y install curl
ENTRYPOINT ["curl","-s","http://ip.cn"]
ONBUILD RUN echo "some one extend me！，I am father image."

定义为 ip_father

FROM ip_father
RUN yum install -y curl
CMD ["curl","s","http://ip.cn"]

4.4 自定义镜像Tomcat9

# 1、创建一个目录，级联创建
mkdir -p /dufy/mydockerfile/tomat9
# 2、在上面的目录，创建一个c.txt，为了演示 copy 
touch c.txt
# 3、将JDK和tomcat安装的压缩包拷贝进上一步的目录 
apapche-tomcat-9.tar.gz
jdk-8u171-linux64.tar.gz

# 4、在 /dufy/mydockerfile/tomat9 目录新建Dockerfile文件 
-------------------------------------------------
FROM centos
MAINTAINER dufy@qq.com
# 把宿主机当前上下文的 c.txt 拷贝到容器 /usr/local 路径下
COPY c.txt /usr/local/cincontainer.txt
# 把java 和 tomcat 添加到容器中
ADD jdk-8u171-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.8.tar.gz  /usr/local/
# 安装vim编辑器
RUN yun -y install vim
# 设置工作访问时候的workdir 路径。登录落脚点
ENV mypath /usr/local
WORKDIR $mypath
# 配置java与tomcat 环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_171
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.8
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.8
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin:$CATALINA_BASE/bin
# 容器运行时监控的端口
EXPOSE 8080
# 启动时运行tomcat
# ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh"]
# CMD ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh"]
CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out
-------------------------------------------------

# 5、构建.当前Dockerfile 目录
docker build Dockerfile -t image:tag .

# 6、运行 run
docker run -d -p 9080:8080 --name mytomcat9 -v /dufy/mydockerfile/tomcat9/test:/usr/local/apache-tomcat-9.0.8/webapps/test -v /dufy/mydockerfile/tomcat9/logs:/usr/local/apache-tomcat-9.0.8/logs --privileged=true image

# 7、验证

# 8、结合前述的容器卷，将测试的web服务test发布

4.5 自定义nginx

FROM nginx:1.14-alpine
LABEL 
ENV NGX_DOC_ROOT='/data/web/html' 
ADD entrypoint.sh /bin/
ADD index.html $NGX_DOC_ROOT
EXPOSE 80/tcp
HEALTHCHECK --start-period=3s CMD wget -O - -q http://${IP:-0.0.0.0}:${PORT:-80}/
CMD ["/usr/sbin/nginx","-g","daemon off"]
ENTRYPOINT ["/bin/entrypoint.sh"] # 要使用双引号 ，不能用单引号

entorypoint.sh
#!/bin/sh
cat  > /etc/nginx/conf.d/www.conf << EOF
server {
	server_name ${HONSTNAME};
	lister ${IP:-0.0.0.0}:${PORT:-80};
	root ${NGX_DOC_ROOT:-/usr/share/nginx/html};
}
EOF
exec "$@" #脚本的所有参数
chmod +x entrypoint.sh

index.html

 
 docker run --name names --rm -P -e "PORT=8080" ngxin:v1.0-1
 netstat -tnl

5、小总结

Docker核心技术学习笔记

七、Docker常用安装

1、总体步骤

搜索镜像
拉取镜像
查看镜像
启动镜像-成为容器
停止容器
移除容器
删除镜像

2、安装Tomcat

3、安装Mysql

（1）、从docker hub上面查找mysql镜像

（2）、从docker hub上拉取 mysql镜像到本地

（3）、运行mysql镜像，启动一个mysql容器

docker run -p 3307:3306 --name mysql01 -v /dufy/mysql/conf:/etc/mysql/conf.d -v /dufy/mysql/logs:/logs -v /dufy/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6

Docker核心技术学习笔记

数据备份测试：

docker exec mysql服务容器id sh -c 'exec mysqldump --all-databases -uroot -p"123456"' > /dufy/all-databases.sql

4、安装Redis

（1）、从docker hub 拉取redis镜像到本地，下载tag 3.2

（2）、运行redis镜像创建容器

1、使用镜像
docker run -p 6379:6379 -v /dufy/myredis/data:/data -v /dufy/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes

2、在主机/dufy/myredis/conf/redis.conf 目录下新建redis.conf 文件
vim /dufy/myredis/conf/redis.conf/redis.conf

去掉 bind 绑定 主机
3、测试redis-cli连接
docker  exec -it 容器id redis-cli
4、测试持久化文件生成
shutdown ,dicker容器redis停止了

cd  /dufy/myredis/data # 是否有备份文件

八、本地镜像发布到阿里云

本地镜像发布到阿里云的流程

Docker核心技术学习笔记

镜像的生成方法

1、前面的Dockerfile ,编写完后 build 

2、从容器创建一个新的镜像，docker commit [options] 容器id  [repository[:tag]] 
-a：提交的镜像作者
-m：提交时候的说明文字

例子：
docker commit -a dufy -m "new tomcat" 容器id myTomcat:1.0

注：commit 需要容器在运行状态。

将本地镜像推送到阿里云

1、本地镜像素材原型
2、阿里云开发者平台 -- http://dev.aliyun.com/search.html
3、创建仓库镜像 
	命名空间
	仓库名称
4、将镜像推送到registry 
	-- 初次进入需要设置密码
	-- 镜像名字要符合aliyun的要求
5、公有云可以查询到
6、查看详情

将阿里云上的镜像下载到本地

注：镜像也可以推送到Docker hub上面。

九、Docker 私有Registry

1、 Docker Registry 分类

Registry 用于保存Docker镜像，包括镜像的层次结构和元数据。

用户可以自建Registry，也可以使用官方的Docker hub.(此处类似用户可以使用自建gitlab，也可以使用github)

分类	说明
Sponsor Registry	第三方的Registry，供客户和Docker社区使用
Mirror Registry	第三方的Registry，只让客户使用
Vendor Registry	由发布Docker 镜像的供应商提供的Registry
Private Registry	通过设有防火墙和额外安全层的私有实体提供的Registry

Docker 拒绝使用http协议。

docker-distribution

2、Registry 安装

yum info docker-registry

yum install docker-registry

rpm -ql docker-distribution

cd /etc/docker/registry 
config.yml # 使用默认配置即可


ss -tnl


docker tag 镜像名：tag  hostname:port/镜像名：tag

docker push hostname:port/镜像名：tag
#报错 默认不支持 http协议

在daemon.json 加上 insecure-registries:["hostname:prot"]

重启Docker 

history

!行数 # 执行历史命名
  
# 查看上传的镜像
cd /var/lib/registry/docker/registry


# 下载上传到私有Registry的镜像

3、构建本地完整的私有仓库 – harbor

vmvare harbor

docker compose

github 有 harbor

lftp mget bye

yum -y install docker-compose 1.7+

十、Docker的系统资源限制及验正

ＯＯＭＥ：　E代表异常。一旦发生OOME，任何进程都可能被杀死，包括docker daemon在内。为此Docker 特地调整了docker daemon 的OOME优先级，以免它被内核“正法”，但容器的优先级并未调整。

可以限制一个容器可用的内存。

如果需要Docker相关的学习资料和视频，可以关注下方公众号获取。
在这里插入图片描述

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/120990.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权正版激活】： 官方授权正版激活支持Jetbrains家族下所有IDE 使用个人JB账号...

Docker核心技术学习笔记

Docker核心技术

文章目录

一 、Docker简介

二、Docker安装

前提说明

Docker 的基本组成

安装

centos 7 安装docker

启动hello-world

底层原理

三、Docker常用命令

帮助命令

镜像命令

容器命令

总结

四、Docker 镜像

1、镜像是什么？

2、镜像特点

3、Docker镜像commit操作补充

4 、镜像生成的途径

5、 镜像导入导出

6、镜像推送到仓库

五、Docker容器数据卷

1、是什么

2、能干嘛

3、数据卷

4、数据容器卷

六、DockerFile解析

1、是什么

2、DockerFile构建过程解析

3、DockerFile体系结构(保留字指令)

4、案例

4.1 Base镜像（scratch）

4.2 自定义镜像

4.3 CMD/ENTRYPOINT 镜像案例

4.4 自定义镜像Tomcat9

4.5 自定义nginx

5、小总结

七、Docker常用安装

1、总体步骤

2、安装Tomcat

3、安装Mysql

4、安装Redis

八、本地镜像发布到阿里云

九、Docker 私有Registry

1、 Docker Registry 分类

2、Registry 安装

3、构建本地完整的私有仓库 – harbor

十、Docker的系统资源限制及验正

相关推荐

linuxdocker常用命令_查看docker

docker（11）Dockerfile 中的COPY与ADD 命令

每天5分钟玩转docker容器技术 pdf_docker 创建容器

写一个 docker 打击一系列手册

docker镜像和docker容器的关系_docker基础镜像和项目镜像

docker部署web项目_小钢炮docker安装web

发表回复

一、Docker简介

5、镜像导入导出