Docker 之完整入门

Docker 一篇入门

一、Docker 简介

1、基本概述

Docker是世界领先的软件容器平台。

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

Docker的主要目标是“Build，Ship and Run Any App,Anywhere”。

通过对应用组件的封装、分发、部署、运行等生命周期的管理，使用户的APP（可以是一个WEB应用或数据库应用等等）及其运行环境能够做到“一次封装，到处运行”。

因为虚拟机模拟的就是带操作系统和环境的，其资源占用多、冗余步骤多、启动慢等不足，Linux 发展出了另一种虚拟化技术：Linux 容器（Linux Containers，缩写为 LXC）。Linux 容器不是模拟一个完整的操作系统，而是对进程进行隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。

Docker 在Linux 容器技术的基础上发展过来的。将应用运行在 Docker 容器上面，而 Docker 容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务器。只需要一次配置好环境，换到不同的机器上就可以一键部署好，大大简化了操作。这样是顺应了 DevOps 开发运维理念。

针对集群环境，可以快速部署安装。

意义或作用：

Docker 解决了运行环境和配置问题软件容器，方便做持续集成并有助于整体发布的容器虚拟化技术。

2、官网及仓库

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

docker中文网站：https://www.docker-cn.com

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

二、Docker 安装

1、环境检查

CentOS Docker 安装
Docker支持以下的CentOS版本：
CentOS 7 (64-bit)
CentOS 6.5 (64-bit) 或更高的版本

前提条件
目前，CentOS 仅发行版本中的内核支持 Docker。
Docker 运行在 CentOS 7 上，要求系统为64位、系统内核版本为 3.10 以上。
Docker 运行在 CentOS-6.5 或更高的版本的 CentOS 上，要求系统为64位、系统内核版本为 2.6.32-431 或者更高版本。

Linux 检查内核版本命令：

 uname -a
 cat /proc/version
 lsb_release -a

如果命令 lsb_release -a提示command not found则需要安装yum install redhat-lsb -y。

2、基本组成

docker主机(Host)：安装了Docker程序的机器，Docker直接安装在操作系统（windows / linux）上；
docker客户端(Client)：连接docker主机进行操作；
docker仓库(Registry)：用来保存各种打包好的软件镜像；
docker镜像(Images)：软件打包好的镜像；放在docker仓库中；
docker容器(Container)：镜像启动后的实例称为一个容器；容器是独立运行的一个或一组应用。

架构图：

3、安装步骤

官方文档也有安装步骤：https://docs.docker.com/install/linux/docker-ce/centos/

Centos 6.8 安装Docker：

（1）环境准备

Docker使用EPEL发布，RHEL系的OS首先要确保已经持有EPEL仓库，否则先检查OS的版本，然后安装相应的EPEL包。

yum install -y epel-release

（2）安装docker

yum install -y docker-io

（3）配置文件

安装后的配置文件：/etc/sysconfig/docker

（4）启停操作

service docker start
service docker stop

（5）验证

docker version

Centos 7 安装Docker：

（1）环境检查

版本确认：

cat /etc/redhat-release

联网检查

（2）gcc环境安装

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

（3）旧版卸载

可参考官网操作，新机器可省略此操作。

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

（4）安装依赖包

yum install -y yum-utils device-mapper-persistent-data lvm2

（5）修改镜像仓库

主要是为了优化下载速度

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

（6）更新yum包索引

yum makecache fast

（7）安装Docker CE

yum -y install docker-ce

（8）启停操作

systemctl start docker
systemctl stop docker

（9）测试验证

docker version

（10）配置镜像加速

mkdir -p /etc/docker
vim /etc/docker/daemon.json
systemctl daemon-reload  # 重新加载
systemctl restart docker # 重启

daemon.json 内容：

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

或

 #阿里云
{
  "registry-mirrors": ["https://｛自已的编码｝.mirror.aliyuncs.com"]
}

不注册就是用

{ 
"registry-mirrors": ["https://registry.docker-cn.com", "http://hub-mirror.c.163.com","https://docker.mirrors.ustc.edu.cn"] 
}

（11）卸载docker

systemctl stop docker
yum -y remove docker-ce
rm -rf /var/lib/docker

关于阿里云或网易云镜像加速

注册阿里云账户，登录阿里云开发者平台，获取加速器地址，配置参考第（10）步。

（12）更多命令

​ （A） ：Docker 官方文档

​ （B）：参考每一个镜像的文档。

三、Docker 原理

Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上， 然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。

容器，是一个运行时环境，鲸鱼背上的一个个小集装箱。

生命周期

Docker 容器的生命周期里分为五种状态，其分别代表着：

• Created：容器已经被创建，容器所需的相关资源已经准备就绪，但容器中的程序还未处于运行状态。
• Running：容器正在运行，也就是容器中的应用正在运行。
• Paused：容器已暂停，表示容器中的所有程序都处于暂停 ( 不是停止 ) 状态。
• Stopped：容器处于停止状态，占用的资源和沙盒环境都依然存在，只是容器中的应用程序均已停止。
• Deleted：容器已删除，相关占用的资源及存储在 Docker 中的管理信息也都已释放和移除。

四、常用命令

1、帮助命令

docker version
docker info
docker --help

2、镜像命令

（1）搜索镜像

可以直接在：https://hub.docker.com 搜索。

使用命令搜索镜像：

docker search [OPTIONS] images_name

OPTIONS:

• –no-trunc ：显示完整的镜像描述。
• -s ：列出收藏数不小于指定值的镜像。
• –automated：只列出automated build 类型的镜像。

（2）下载镜像

docker pull images_name[:tag]

（3）显示本地镜像

docker images [OPTIONS]

OPTIONS：

• -a ：列出本地所有镜像
• -q ：只显示镜像ID。
• –digests ：显示镜像的摘要信息
• –no-trunc ：显示完整的镜像信息

（3）删除本地镜像

删除单个镜像：

docker rmi -f images_id

删除多个镜像：

docker rmi -f images_name1:tag  images_name2:tag 

删除全部镜像：

docker rmi -f $(docker images -qa)

（4）提交镜像

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

这个命令一般可以个性化好容器之后，制作成自己的镜像模板。

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

OPTIONS说明：

• -a ：提交的镜像作者；
• -c ：使用Dockerfile指令来创建镜像；
• -m ：提交时的说明文字；
• -p ：在commit时，将容器暂停。

示例：

# 将容器a404c6c174a2 保存为新的镜像,并添加提交人信息和说明信息。
docker commit -a "xiaocai.com" -m "my mysql" a404c6c174a2  mymysql:v1 

（5）登录与提交

之所以要登录是因为要把本地镜像提交到镜像仓库，默认为官方仓库Docker Hub，也可以自己搭建自己的镜像仓库。

登录：

docker login -u username -p password

退出：

docker logout

本地镜像提交到镜像仓库

docker push [OPTIONS] NAME[:TAG]

OPTIONS说明：

• –disable-content-trust ：忽略镜像的校验,默认开启

3、容器命令

（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

• –volume , -v： 绑定一个卷。

  此处只列举常用参数，还有其他参数可参考官网命令参数说明。

示例1：

#使用镜像centos:latest以交互模式启动一个容器,在容器内执行/bin/bash命令。
docker run -it centos /bin/bash 

退出容器

以交互模式启动一个容器之后，退出容器：

exit ：容器停止并退出。

CTRL + P + Q ：容器不停止并退出。

进入正在运行的容器

方式一：

docker exec -it container-id  /bin/bash

方式二：

docker attach container-id 

二者区别：

attach ： 直接进入容器启动命令的终端，不会启动新的进程。

exec ：是在容器中打开新的终端，并且可以启动新的进程。

示例2：（常用）

#使用镜像centos:latest以后台守护进程模式启动一个容器
docker run -d centos

（2）查看正在运行的容器

docker ps [OPTIONS]

OPTIONS：

• -a ：列出当前所有正在运行的容器+历史上运行过的
• -l ：显示最近创建的容器。
• -n：显示最近n个创建的容器。
• -q ：静默模式，只显示容器编号。
• –no-trunc ：不截断输出。

（3）容器存在之后的启停删

# 启动容器
docker start container-id | container-name
# 重启容器
docker restart container-id | container-name
# 停止容器
docker stop container-id | container-name
# 暴力停止容器-拔电源
docker kill container-id | container-name
# 删除容器
docker rm container-id 
# 强制删除多个容器
docker rm -f $(docker ps -a -q)
docker  ps -a -q | xargs docker rm

（4）查容器信息（重点）

查看容器日志

docker logs -f -t --tail  container-id

-t ：加入时间戳

-f ：跟随最新的日志打印

–tail 300 ：显示最后300条日志

查看容器内运行的进程

docker  top container-id

查看容器内部细节

docker  inspect container-id

从容器内拷贝文件到宿主机

docker cp container-id:容器内路径  目标主机路径

示例：

docker cp f1faf3c3c6c5:/usr/local/cptest/container_test.txt  /tmp/test.txt

命令关键词	作用
attach	Attach to a running container # 当前 shell 下 attach 连接指定运行镜像
build	Build an image from a Dockerfile # 通过 Dockerfile 定制镜像
commit	Create a new image from a container changes # 提交当前容器为新的镜像
cp	Copy files/folders from the containers filesystem to the host path #从容器中拷贝指定文件或者目录到宿主机中
create	Create a new container # 创建一个新的容器，同 run，但不启动容器
diff	Inspect changes on a container’s filesystem # 查看 docker 容器变化
events	Get real time events from the server # 从 docker 服务获取容器实时事件
exec	Run a command in an existing container # 在已存在的容器上运行命令
export	Stream the contents of a container as a tar archive # 导出容器的内容流作为一个 tar 归档文件[对应 import ]
history	Show the history of an image # 展示一个镜像形成历史
images	List images # 列出系统当前镜像
import	Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export]
info	Display system-wide information # 显示系统相关信息
inspect	Return low-level information on a container # 查看容器详细信息
kill	Kill a running container # kill 指定 docker 容器
load	Load an image from a tar archive # 从一个 tar 包中加载一个镜像[对应 save]
login	Register or Login to the docker registry server # 注册或者登陆一个 docker 源服务器
logout	Log out from a Docker registry server # 从当前 Docker registry 退出
logs	Fetch the logs of a container # 输出当前容器日志信息
port	Lookup the public-facing port which is NAT-ed to PRIVATE_PORT # 查看映射端口对应的容器内部源端口
pause	Pause all processes within a container # 暂停容器
ps	List containers # 列出容器列表
pull	Pull an image or a repository from the docker registry server # 从docker镜像源服务器拉取指定镜像或者库镜像
push	Push an image or a repository to the docker registry server # 推送指定镜像或者库镜像至docker源服务器
restart	Restart a running container # 重启运行的容器
rm	Remove one or more containers # 移除一个或者多个容器
rmi	Remove one or more images # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除]
run	Run a command in a new container # 创建一个新的容器并运行一个命令
save	Save an image to a tar archive # 保存一个镜像为一个 tar 包[对应 load]
search	Search for an image on the Docker Hub # 在 docker hub 中搜索镜像
start	Start a stopped containers # 启动容器
stop	Stop a running containers # 停止容器
tag	Tag an image into a repository # 给源中镜像打标签
top	Lookup the running processes of a container # 查看容器中运行的进程信息
unpause	Unpause a paused container # 取消暂停容器
version	Show the docker version information # 查看 docker 版本号
wait	Block until a container stops, then print its exit code # 截取容器停止时的退出状态值

五、Docker 镜像

1、Docker 镜像是什么

UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。

镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

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

镜像（Images）可以看成是由多个镜像层叠加起来的一个文件系统（通过UnionFS与AUFS文件联合系统实现），镜像层（ Image Layer）也可以简单理解为一个基本的镜像，而每个镜像层之间通过指针的形式进行叠加。

Docer镜像的特点：

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

2、Docker镜像加载原理

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

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

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

docker镜像里的centos 系统大小约 200M，对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。

在执行pull 命令下载镜像的时候，可以看到docker的镜像好像是在一层一层的在下载。

为什么要使用分层呢？

最主要的是可以实现共享资源

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

六、Docker 容器数据卷

Docker 容器数据卷主要是为了容器的持久化，方便容器间继承和数据共享。

数据卷命令

1.创建数据卷

docker volume  create  数据卷名称

创建数据卷之后默认存放在：/var/lib/docker/volumes/数据卷名称/_data

2.查看全部数据卷

docker volume  ls

3.查看数据卷详细信息

docker volume  inspect 数据卷名称

4.删除数据卷

docker volume  rm 数据卷名称

5.应用数据卷

# 数据卷不存在时docker 自动创建。会将数据卷内部自带文件存储在默认的存放路径中
docker run -v 数据卷名称:容器内部路径  镜像ID

# 直接指定一个路径作为容器卷的存放位置，路径是空的。（推荐）
docker run -v  路径:容器内部路径

1、容器添加数据卷

（1）直接命令添加

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

带权限的命令：

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

rw ：read write 读写权限，默认

ro ：read only 只读权限

wo ：write only 只写权限

查看数据卷是否挂载成功

docker inspect container-id

如果测试容器和宿主机直接数据共享，可以尝试从宿主机修改文件，进入容器查看是否修改，再反过来操作一次。

出错描述：Docker挂载主机目录Docker访问出现 cannot open directory .: Permission denied
解决办法：在挂载目录后多加一个–privileged=true参数即可。

（2）DockerFile添加

根目录新建一个 mydocker 文件夹进入，然后创建一个dockerfile文件，内容：

# volume test
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "finished,--------success1"
CMD /bin/bash

这里在 Dockerfile 中使用VOLUME指令来给镜像添加一个或多个数据卷。

VOLUME["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]

说明：出于可移植和分享的考虑，用-v 主机目录:容器目录这种方法不能够直接在Dockerfile中实现。由于宿主机目录是依赖于特定宿主机的，并不能够保证在所有的宿主机上都存在这样的特定目录。

使用 build 生成镜像

docker build -f /mydocker/dockerfile -t xiaocai/centos

如果生成成功则可以使用docker images查看

运行容器 docker run it centos-container-id /bin/bash

使用 docker inspect centos-container-id 查看容器内的卷目录地址对应的主机目录地址

一般是：/var/lib/docker/volumes/container-id/_data

2、容器数据卷

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

容器传递共享 --volumes-from

比如：以上面的 xiaocai/centos 为模板启动容器 dk_centos_01/dk_centos_02/dk_centos_03

先启动父容器：dk_centos_01，然后在在/dataVolumeContainer2 目录新增内容

启动：dk_centos_02和dk_centos_03

docker run -it --name dk_centos_02 --volumes-from dk_centos_01 zzyy/centos
docker run -it --name dk_centos_03 --volumes-from dk_centos_01 zzyy/centos

在dk_centos_02和dk_centos_03分别在/dataVolumeContainer2各自新增内容test2.txt、test3.txt

回到dk_centos_01可以看到dk_centos_02和dk_centos_03各自添加的都能共享了。

删除dk_centos_01，dk_centos_02修改后dk_centos_03依然可以访问。

新建dk_centos_04继承dk_centos_03后再删除dk_centos_03，dk_centos_04也已经继续访问共享。

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

七、DockerFile解析

1、DockerFile是什么

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

一般分三步骤：

（1）编写DockerFile文件

（2）执行 docker build 命令，从容器生成镜像

（3）运行docker run 命令，运行新的容器

比如centos的dockerfile 文件，在：https://github.com/CentOS/sig-cloud-instance-images/blob/f2788ce41161326a18420913b0195d1c6cfa1581/docker/Dockerfile

FROM scratch
ADD centos-7-x86_64-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="20200809" \
org.opencontainers.image.title="CentOS Base Image" \
org.opencontainers.image.vendor="CentOS" \
org.opencontainers.image.licenses="GPL-2.0-only" \
org.opencontainers.image.created="2020-08-09 00:00:00+01:00"

CMD ["/bin/bash"]

2、DockerFile构建过程

DockerFile 内容基本认识：

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

（2）指令按照从上到下的顺序执行。

（3）使用 # 表示注释

（4）每条指令都会创建一个新的镜像层，并对镜像进行提交。（参考Docker原理）

Docker执行DockerFile 主要基本流程：

（1）docker从基础镜像运行一个容器。

（2）执行一条指令并对容器作出修改。

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

（4）docker再基于刚提交的镜像运行一个新容器

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

从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，

• Dockerfile是软件的原材料
• Docker镜像是软件的交付品
• Docker容器则可以认为是软件的运行态。
  Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

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

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

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

3、DockerFile 指令

指令	含义
FROM	基础镜像，当前镜像是基于哪个镜像的
MAINTAINER	镜像维护者的姓名和邮箱地址
RUN	容器构建时需要运行的命令
EXPOSE	当前容器对外暴露的端口
WORKDIR	指定在创建容器后，终端默认登录进入的工作目录
ENV	构建镜像过程中设置环境变量
ADD	将指定宿主机目录文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
COPY	类似ADD，拷贝文件到目录到镜像中。将构建上下文目录的文件复制到新的一层镜像内的目录路径。COPY src dest, COPY ["src","dest"]
VOLUME	容器数据卷，用于数据保存和持久化工作
CMD	指定一个容器启动时要运行的命令。 Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换
ENTRYPOINT	指定一个容器启动时要运行的命令。 ENTRYPOINT 的目的 和 CMD 命令 一样，都是指定容器启动程序及参数
ONBUILD	当构建一个被继承的DockerFile 时运行命令，父镜像在被子继承后父镜像的onbuild被触发

FROM scratch ：大多数镜像都是通过base 镜像（scratch）中安装配置需要的软件构建出来。

CMD 指令的格式和 RUN 相似，也是两种格式：

（1）shell 格式：CMD <命令>

（2）exec 格式：CMD ["可执行文件"，"参数1","参数2"...]

参数列表的格式：CMD ["参数1","参数2"...] 在指定了 ENTRYPOINT 指令后，用CMD 指定具体的参数。

Dockerfile 指令分类

BUILD	BOTH	RUN
FROM	WORKDIR	CMD
MAINTAINER	USER	ENV
COPY		EXPOSE
ADD		VOLUME
RUN		ENTRYPOINT
ONBUILD
.dockerignore

4、DockerFile 学习示例

编写Dockerfile 示例一：

下载的centos镜像，新建并运行容器，默认的centos 是不能执行 ifconfig 、vim、 rz 、sz 等命令。现在编写一个dockerfile 用来构建一个自定义的centos 容器取名为 xiaocai_centos

（1）下载centos 镜像

docker pull centos

（2）以centos为镜像模板启动容器并进入容器

docker run -it centos

可以尝试执行上述所说不能执行的命令，确认现在是否可以执行，其实是不能执行的。

（3）编写DockerFile 文件

mkdir -p xiaocai/dockerfiles
cd /xiaocai/dockerfiles
vi Dockerfile

Dockerfile 内容如下：

FROM centos
MAINTAINER xiaocai

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

ENV MYPATH /usr/local
WORKDIR $MYPATH

保存文件。

（4）构建出新的镜像

docker build -t xiaocai_centos:1.1

最初出现 successfully build 字样表示构建成功。

（5）运行新的镜像

# 可以先查看本地镜像
docker images
# 以交互方式运行新的镜像
docker run -it xiaocai_centos:1.1

此时，如果正常可以执行ifconfig vim命令，如果你在windows机器使用SSH链接工具，执行 rz 命令，会弹出选择文件的窗口。

（6）列出镜像的变更历史

docker history centos

编写Dockerfile 示例二：

CMD / ENTRYPOINT 都是指定一个容器启动时要运行的命令。

CMD：

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

如在centos 镜像中，最后一个CMD 是 CMD ["/bin/bash"]

现在以默认的centos为镜像模板运行一个centos 实例：

docker run -it -p 8888:8080 tomcat ls -l

这里CMD ["/bin/bash"] 不会执行，而是被 -it -p 8888:8080 tomcat ls -l 替换。

ENTRYPOINT ：

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

制作CMD版可以查询IP信息的容器，使用curl 命令

curl命令可以用来执行下载、发送各种HTTP请求，指定HTTP头部等操作。

如果系统没有curl可以使用yum install curl安装，也可以下载安装。
curl是将下载文件输出到stdout

使用命令：curl http://www.baidu.com
执行后，www.baidu.com的html就会显示在屏幕上了

（1）新建一个用作构建的文件夹

mkdir -p xiaocai/ipselect01
cd xiaocai/ipselect01

（2）编写Dockerfile 文件

vi Dockerfile

文件内容：

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

（3）构建新镜像

docker build -f Dockerfile -t ipselect01

（4）运行新镜像的容器

docker run  ipselect01

直接运行则会默认执行Dockerfile 最后一条CMD，结果返回IP信息。

如果希望显示 HTTP 头信息，就需要加上-i参数，即：docker run ipselect01 -i

但是如果直接执行就会报错，因为 允许多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换。

重新使用 ENTRYPOINT 重新构建新的镜像：

（1）新建一个用作构建的文件夹

mkdir -p xiaocai/ipselect02
cd xiaocai/ipselect02

（2）编写Dockerfile 文件

vi Dockerfile

文件内容：

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

（3）构建新镜像

docker build -f Dockerfile -t ipselect02

（4）运行新镜像的容器

docker run  ipselect02

直接运行则会默认执行Dockerfile 最后一条CMD，结果返回IP信息。

（5）参数执行验证

带上参数运行：

docker run  ipselect02 -i

此时如果正常，可以看到显示 HTTP 头信息。

编写Dockerfile 示例三：

自己构建一个tomcat的镜像，先下载好tomcat的tar包，和jdk的tar 包，centos环境。

（1）新建一个用作构建的文件夹

mkdir -p xiaocai/tomcat9
cd xiaocai/tomcat9
touch test_copy.txt

（2）将jdk 和 tomcat 安装的压缩包拷贝到 /xiaocai/tomcat9 ，并在目录下新建Dockerfile 文件。

到此一步，那么/xiaocai/tomcat9 目录有四个文件：

• test_copy.txt
• jdk的tar包 （jdk-8u171-linux-x64.tar.gz）
• tomcat的tar包（apache-tomcat-9.0.8.tar.gz）
• Dockerfile 文件

（3）编写Dockerfile， 内容如下：

# 表示基于 centos 开始构建
FROM         centos
MAINTAINER    xiaocai<smallrose@qq.com>
#把宿主机当前上下文的test_tomcat.txt拷贝到容器/usr/local/路径下
COPY test_copy.txt /usr/local/test_copy_container.txt
#把java与tomcat添加到容器中
ADD jdk-8u171-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.8.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#安装网络工具
RUN yum -y install net-tools
#设置工作访问时候的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/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE  8080
#启动时运行tomcat
# ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh" ]
# CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"]
#启动值可以直接打印出tomcat日志
CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out

（4）构建新的镜像

docker build -t xiaocai_tomcat:2.0
docker images

（5）运行新的镜像

docker run -d -p 9080:8080 --name xiaocai_tomcat9 -v /xiaocai/tomcat9/test:/usr/local/apache-tomcat-9.0.8/webapps/test -v /xiaocai/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.8/logs --privileged=true xiaocai_tomcat:2.0

这里将宿主机的/xiaocai/tomcat9/test 目录与容器/usr/local/apache-tomcat-9.0.8/webapps/test项目部署目录映射就是为了方便部署项目。

（6）验证访问

在 /xiaocai/tomcat9/test 目录下新建一个html 或 jsp ，然后访问tomcat，不出错的话可以看到页面。

如果不想建页面也可以直接访问tomcat 的页面。

八、Docker 常用安装

常用的安装比如：mysql、tomcat、redis

基本安装步骤：

（1）搜索镜像

（2）拉取镜像

（3）查看镜像

（4）启动镜像实例

（5）停止容器

（6）删除容器

1、安装tocmat

（1）搜索tomcat

在docker hub 找到需要的tomcat及版本

docker search tomcat

（2）拉取tomcat 镜像

# 默认拉取最新版
docker pull tomcat
# 拉取特点版本的
docker pull tomcat:7.0

（3）查看镜像

# 查看镜像
docker images 

（4）使用tomcat镜像创建容器实例

docker run -it -p 8080:8080 tomcat

• -i ：交互

• -t ：终端

• -p ：端口映射，主机端口: 容器端口

• -P ：随机端口

2、安装mysql

（1）搜索mysql

在docker hub 找到需要的mysql及版本

docker search mysql

（2）拉取mysql镜像

# 默认拉取最新版
docker pull mysql
# 拉取特点版本的
docker pull mysql:5.7

（3）查看镜像

# 查看镜像
docker images 

（4）使用mysql镜像创建容器实例

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

命令说明：
-p 3306:3306：将主机的3306端口映射到docker容器的3306端口。
--name mysql：运行服务名字
-v /xiaocai/mysql/conf:/etc/mysql/conf.d：将主机/xiaocai/mysql录下的conf/my.cnf 挂载到容器的 /etc/mysql/conf.d目录
-v /xiaocai/mysql/logs:/logs：将主机/xiaocai/mysql目录下的 logs 目录挂载到容器的 /logs。
-v /xiaocai/mysql/data:/var/lib/mysql ：将主机/xiaocai/mysql目录下的data目录挂载到容器的 /var/lib/mysql
-e MYSQL_ROOT_PASSWORD=123456：初始化 root 用户的密码。
-d mysql:5.7: 后台程序运行mysql5.7

检查mysql容器运行

docker ps -a

如果使用命令行登录mysql，则首先进入容器：

docker exec -it MySQL运行成功后的容器ID   /bin/bash

进行容器之后可以使用 mysql -u -p的命令进行登录操作。

在宿主机直接执行命令进行数据备份：

docker exec myql服务容器ID sh -c ' exec mysqldump --all-databases -uroot -p"123456" ' > /xiaocai/all-databases.sql

也可以使用mysql客户端连接，注意宿主机端口。

2、安装redis

（1）搜索redis

在docker hub 找到需要的redis及版本

docker search redis

（2）拉取redis镜像

# 默认拉取最新版
docker pull redis
# 拉取特点版本的
docker pull redis:3.2

（3）查看镜像

# 查看镜像
docker images 

（4）使用redis镜像创建容器实例

docker run -p 6379:6379 -v /xiaocai/myredis/data:/data -v /xiaocai/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf  -d redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes

在主机/xiaocai/myredis/conf/redis.conf目录下新建redis.conf文件

vim /xiaocai/myredis/conf/redis.conf/redis.conf

文件内容：

redis.conf

（5）测试连接

docker exec -it 运行着Rediis服务的容器ID redis-cli

执行redis 的set/get命令进行数据保存查询操作。

（6）持久化验证

执行shutdown 停止redis

进入/xiaocai/myredis/data目录查看持久化文件。