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的系统资源限制及验正

思维导图： 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 基本原理及快速入门

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-release3、yum安装gcc相关
yum -y install gcc
yum -y install gcc-c++
gcc  -v4、卸载旧的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 fast8、安装docker ce
yum -y install docker-ce9、启动docker
systemctl start docker10、测试
docker version
docker run  hello-world11、配置进行加速配置
(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 docker12、停止docker服务
systemctl stop docker
13、卸载
yum -y remove docker-ce
rm -rf /var/lib/docker

启动hello-world

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

run 启动容器。

底层原理

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:containerPortip::containerPorthostPort: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 /tmpdocker exec -t 3d51887b06b6 /bin/bash# 重新进入docker attach 容器id
docker attach 3d51887b06b6
上述两个区别：
- attach：直接进入容器启动命令的终端，不会启动新的进程
- exec：在容器中打开新的终端，并可以启动新的进程

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

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

总结

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

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

四、Docker 镜像

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

1、镜像是什么？

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

  • UnionFS（联合文件系统）

  • Docker镜像加载原理

  • 分层的镜像

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

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

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

问题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容器当作一个模板，提交commit4、启动新镜像 和 原来对比

4 、镜像生成的途径

5、 镜像导入导出

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

docker save -o tomcatimage.gz dufy/tomcat:v0.9 dufy/tomcat:v1.0docker 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.txtdocker 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.txtdocker 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）小总结

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

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

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

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

  • 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

  • 保留字运行的阶段

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 $mypathrun yum -y install vim
run yum -y install net-toolsexpose 80cmd 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_fatherFROM 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.shindex.htmldocker run --name names --rm -P -e "PORT=8080" ngxin:v1.0-1netstat -tnl

5、小总结

七、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 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 yes2、在主机/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 # 是否有备份文件

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

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

  • 镜像的生成方法
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-registryyum install docker-registryrpm -ql docker-distributioncd /etc/docker/registry
config.yml # 使用默认配置即可ss -tnldocker tag 镜像名：tag  hostname:port/镜像名：tagdocker 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相关的学习资料和视频，可以关注下方公众号获取。

Docker核心技术学习笔记相关推荐

  1. 《自己动手写Docker》学习笔记2

    <自己动手写Docker>学习笔记2 1 前言 由于本人毕业设计与云原生领域相关,因此最近在学习Docker相关知识,<自己动手写Docker>涵盖了Docker底层的各类知识 ...

  2. 《深入浅出Docker》学习笔记

    <深入浅出Docker>学习笔记 第三章:docker 安装 linux服务器安装:-略 windows服务器安装:-略 确认安装结果 docker --version 第四章:纵观DOc ...

  3. Docker容器学习笔记一

    Docker容器学习笔记一 狂神说B站视频:https://www.bilibili.com/video/BV1og4y1q7M4?p=1 Docker容器学习笔记二:https://blog.csd ...

  4. [硬核]卷起来！两万六千字总结的JavaWeb核心技术学习笔记

    文章目录 前言 http协议笔记 JavaWEB笔记_1 JavaWEB笔记_2(JSP) JavaWEB笔记_3(web项目) Servlet Tomcat笔记 总结 前言 大家好,我是ChinaM ...

  5. docker,k8s学习笔记汇总

    整理了下博客里关于docker和k8s的文章,方便查看 docker学习笔记(一)docker入门 docker学习笔记(二)创建自己的镜像 docker学习笔记(三)docker中的网络 docke ...

  6. Docker入门学习笔记（狂神版）

    下述笔记是自己花一天时间看B站狂神说Docker视频的笔记,下列的笔记是根据自己的实践的记录下来的,若想细学掌握Docker建议自行观看(<Docker入门到精通>),去观看狂胜的视频记得 ...

  7. 【学习笔记】尚硅谷周阳老师的Docker教程学习笔记

    本文是尚硅谷周阳老师的Docker教程的相关学习笔记,暂时还没有检查勘误过. 一.Docker简介 1. 简介 Docker的出现是为了解决代码在本机可以正常运行,而部署到其他机器不能运行的问题.这是 ...

  8. Docker入门学习笔记

    文章目录 Docker入门学习 Docker为什么出现? 一.Docker的历史 二.Docker做什么 三.Docker 安装 Docker的基本组成 安装Docker 阿里云镜像加速 运行流程 底 ...

  9. Docker容器学习笔记（看了狂神视频）

    狂神的笔记更加系统详细,推荐大家可以去看狂神的视频教程和笔记.我这里仅根据我自己的需求写的笔记,对于需要快速掌握docker的使用的朋友可以参考学习. Docker 背景需求 之前,开发一套环境,上线 ...

最新文章

  1. golang笔记——struct
  2. ARTS打卡计划第四周-ALGORITHM
  3. Windows下用FFmpeg+nginx+rtmp搭建直播环境 实现推流、拉流（超简单教程）
  4. 读债务危机0901：第三部分48个案例研究概要-核心术语表 1、国际收支差额：一个国家/货币区的个人或机构与世界其他地区之间进行的所有交易的余额。 2、国际收支危机：经济危机的一种，表现为一国的国际收
  5. Kotlin实战指南十八：open、internal 关键字使用
  6. 入门案例中使用的组件介绍
  7. 鸿蒙开发版智慧生活,华为发布全新分布式鸿蒙OS，打造全场景智慧生活新体验...
  8. Java Socket TeXT_FULL_WRITING 等问题解决
  9. AST解析基础: 如何写一个简单的html语法分析库
  10. Android实现立体滚轮控件,Camera和Matrix实现真正的3D(WheelView)滚轮控件
  11. u深度重装系统详细教程_如何重装系统 U深度U盘重装系统教程
  12. GFlags使用文档
  13. 景联文科技为自动驾驶DMS系统提供数据采集标注服务
  14. 如何用LOTO示波器TDR方法测试电线长度？
  15. Microchip具有SDI和SQI接口串行SRAM存储器23LC512
  16. PS 颜色表大全-CMYK颜色表（2）
  17. python打印古诗_python教程：利用python基础知识取出对应诗句
  18. Excel:数据分列功能分割文本
  19. Python中的解包用法
  20. 外强中干? -- 中国制造业的软肋(转载)

热门文章

  1. python_subprocess_devenv
  2. Linux系统用户管理和su、sudo详细讲解
  3. cf网通服务器显示不出来,cf连接服务器失败怎么办
  4. Unity3D网络游戏0.6
  5. 苹果home键在哪里设置_苹果x怎么截图 苹果x截图步骤【图文教程】
  6. Google glog 使用
  7. 只要背着电脑，他可以去任何地方
  8. patran如何看屈曲因子_patran常见问题与技巧锦集
  9. 读稻盛和夫《干法》后的几点感悟
  10. 探索云原生数据库，纵观未来科技发展