技术 Docker初体验

@[toc]

1 Docker 是什么?

说了这么多, Docker 到底是个什么东西呢?
我们在理解 Docker 之前,首先得先区分清楚两个概念,容器和虚拟机。
可能很多读者朋友都用过虚拟机,而对容器这个概念比较的陌生。我们用的传统虚拟机如 VMware , VisualBox 之类的需要模拟整台机器包括硬件。
每台虚拟机都需要有自己的操作系统,虚拟机一旦被开启,预分配给它的资源将全部被占用。
每一台虚拟机包括应用,必要的二进制和库,以及一个完整的用户操作系统。
而容器技术是和我们的宿主机共享硬件资源及操作系统,可以实现资源的动态分配。
容器包含应用和其所有的依赖包,但是与其他容器共享内核。
容器在宿主机操作系统中,在用户空间以分离的进程运行。
容器技术是实现操作系统虚拟化的一种途径,可以让您在资源受到隔离的进程中运行应用程序及其依赖关系。
通过使用容器,我们可以轻松打包应用程序的代码、配置和依赖关系,将其变成容易使用的构建块,从而实现环境一致性、运营效率、开发人员生产力和版本控制等诸多目标。
容器可以帮助保证应用程序快速、可靠、一致地部署,其间不受部署环境的影响。
容器还赋予我们对资源更多的精细化控制能力,让我们的基础设施效率更高。

通过下面这幅图,我们可以很直观的反映出这两者的区别所在:
\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zvq29HPU-1589985834510)(en-resource://database/4423:1)\]

Docker 属于 Linux 容器的一种封装,提供简单易用的容器使用接口。它是目前最流行的 Linux 容器解决方案。
而 Linux 容器是 Linux 发展出的另一种虚拟化技术,简单来讲, Linux 容器不是模拟一个完整的操作系统,而是对进程进行隔离,相当于是在正常进程的外面套了一个保护层。
对于容器里面的进程来说,它接触到的各种资源都是虚拟的,从而实现与底层系统的隔离。
Docker 将应用程序与该程序的依赖,打包在一个文件里面。运行这个文件,就会生成一个虚拟容器。
程序在这个虚拟容器里运行,就好像在真实的物理机上运行一样。有了 Docker,就不用担心环境问题。
总体来说 ,Docker 的接口相当简单,用户可以方便地创建和使用容器,把自己的应用放入容器。容器还可以进行版本管理、复制、分享、修改,就像管理普通的代码一样。

2 Docker 的优势

Docker 相比于传统虚拟化方式具有更多的优势:

  • Docker 启动快速属于秒级别。 虚拟机通常需要几分钟去启动。
  • Docker 需要的资源更少。 Docker 在操作系统级别进行虚拟化,Docker 容器和内核交互,几乎没有性能损耗,性能优于通过 Hypervisor 层与内核层的虚拟化。
  • Docker 更轻量。 Docker 的架构可以共用一个内核与共享应用程序库,所占内存极小。同样的硬件环境,Docker 运行的镜像数远多于虚拟机数量,对系统的利用率非常高。
  • 与虚拟机相比,Docker 隔离性更弱。 Docker 属于进程之间的隔离,虚拟机可实现系统级别隔离。
  • 安全性。 Docker 的安全性也更弱,Docker 的租户 Root 和宿主机 Root 等同,一旦容器内的用户从普通用户权限提升为 Root 权限,它就直接具备了宿主机的 Root 权限,进而可进行无限制的操作。虚拟机租户 Root 权限和宿主机的 Root 虚拟机权限是分离的,并且虚拟机利用如 Intel 的 VT-d 和 VT-x 的 ring-1 硬件隔离技术。这种隔离技术可以防止虚拟机突破和彼此交互,而容器至今还没有任何形式的硬件隔离,这使得容器容易受到攻击。
  • 可管理性。 Docker 的集中化管理工具还不算成熟。各种虚拟化技术都有成熟的管理工具,例如 VMware vCenter 提供完备的虚拟机管理能力。
  • 高可用和可恢复性。 Docker 对业务的高可用支持是通过快速重新部署实现的。虚拟化具备负载均衡,高可用,容错,迁移和数据保护等经过生产实践检验的成熟保障机制, VMware 可承诺虚拟机 99.999% 高可用,保证业务连续性。
  • 快速创建、删除。 虚拟化创建是分钟级别的,Docker 容器创建是秒级别的,Docker 的快速迭代性,决定了无论是开发、测试、部署都可以节约大量时间
  • 交付、部署。 虚拟机可以通过镜像实现环境交付的一致性,但镜像分发无法体系化。Docker 在 Dockerfile 中记录了容器构建过程,可在集群中实现快速分发和快速部署。

我们可以从下面这张表格很清楚地看到容器相比于传统虚拟机的特性的优势所在:

特性 容器 虚拟机
启动 秒级 分钟级
硬盘使用 一般为MB 一般为GB
性能 接近原生 弱于
系统支持量 单机支持上千个容器 一般是几十个

3 Docker 的三个基本概念

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oKDSz5xr-1589985834512)(en-resource://database/4425:1)\]

从上图我们可以看到,Docker 中包括三个基本的概念:

  • Image(镜像)
  • Container(容器)
  • Repository(仓库)

镜像是 Docker 运行容器的前提,仓库是存放镜像的场所,可见镜像更是 Docker 的核心。

Image(镜像)

那么镜像到底是什么呢?Docker 镜像可以看作是一个特殊的文件系统,除了提供容器运行时所需的程序、库、资源、配置等文件外,还包含了一些为运行时准备的一些配置参数(如匿名卷、环境变量、用户等)。
镜像不包含任何动态数据,其内容在构建之后也不会被改变。镜像(Image)就是一堆只读层(read-only layer)的统一视角,也许这个定义有些难以理解,下面的这张图能够帮助读者理解镜像的定义:

从左边我们看到了多个只读层,它们重叠在一起。除了最下面一层,其他层都会有一个指针指向下一层。这些层是 Docker 内部的实现细节,并且能够在主机的文件系统上访问到。
统一文件系统(Union File System)技术能够将不同的层整合成一个文件系统,为这些层提供了一个统一的视角。
这样就隐藏了多层的存在,在用户的角度看来,只存在一个文件系统。我们可以在图片的右边看到这个视角的形式。

Container(容器)

容器(Container)的定义和镜像(Image)几乎一模一样,也是一堆层的统一视角,唯一区别在于容器的最上面那一层是可读可写的。
\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xv9Onl0v-1589985834518)(en-resource://database/4429:1)\]

由于容器的定义并没有提及是否要运行容器,所以实际上,容器 = 镜像 + 读写层。

Repository(仓库)

Docker 仓库是集中存放镜像文件的场所。镜像构建完成后,可以很容易的在当前宿主上运行。
但是, 如果需要在其他服务器上使用这个镜像,我们就需要一个集中的存储、分发镜像的服务,Docker Registry(仓库注册服务器)就是这样的服务。
有时候会把仓库(Repository)和仓库注册服务器(Registry)混为一谈,并不严格区分。
Docker 仓库的概念跟 Git 类似,注册服务器可以理解为 GitHub 这样的托管服务。
实际上,一个 Docker Registry 中可以包含多个仓库(Repository),每个仓库可以包含多个标签(Tag),每个标签对应着一个镜像。
所以说,镜像仓库是 Docker 用来集中存放镜像文件的地方,类似于我们之前常用的代码仓库。
通常,一个仓库会包含同一个软件不同版本的镜像,而标签就常用于对应该软件的各个版本 。
我们可以通过<仓库名>:<标签>的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签,将以 Latest 作为默认标签。
仓库又可以分为两种形式:

  • Public(公有仓库)
  • Private(私有仓库)

Docker Registry 公有仓库是开放给用户使用、允许用户管理镜像的 Registry 服务。

一般这类公开服务允许用户免费上传、下载公开的镜像,并可能提供收费服务供用户管理私有镜像。

除了使用公开服务外,用户还可以在本地搭建私有 Docker Registry。Docker 官方提供了 Docker Registry 镜像,可以直接使用做为私有 Registry 服务。

当用户创建了自己的镜像之后就可以使用 Push 命令将它上传到公有或者私有仓库,这样下次在另外一台机器上使用这个镜像时候,只需要从仓库上 Pull 下来就可以了。
我们主要把 Docker 的一些常见概念如 Image,Container,Repository 做了详细的阐述,也从传统虚拟化方式的角度阐述了 Docker 的优势。
我们从下图可以直观地看到 Docker 的架构:
\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7Hfb1fyX-1589985834520)(en-resource://database/4431:1)\]

Docker 使用 C/S 结构,即客户端/服务器体系结构。Docker 客户端与 Docker 服务器进行交互,Docker服务端负责构建、运行和分发 Docker 镜像。
Docker 客户端和服务端可以运行在一台机器上,也可以通过 RESTful 、 Stock 或网络接口与远程 Docker 服务端进行通信。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CBeE5fqf-1589985834522)(en-resource://database/4433:1)]

这张图展示了 Docker 客户端、服务端和 Docker 仓库(即 Docker Hub 和 Docker Cloud ),默认情况下 Docker 会在 Docker 中央仓库寻找镜像文件。
这种利用仓库管理镜像的设计理念类似于 Git ,当然这个仓库是可以通过修改配置来指定的,甚至我们可以创建我们自己的私有仓库。

4 Docker 的安装和使用

Docker 的安装和使用有一些前提条件,主要体现在体系架构和内核的支持上。对于体系架构,除了 Docker 一开始就支持的 X86-64 ,其他体系架构的支持则一直在不断地完善和推进中。
Docker 分为 CE 和 EE 两大版本。CE 即社区版,免费支持周期 7 个月;EE 即企业版,强调安全,付费使用,支持周期 24 个月。
我们在安装前可以参看官方文档获取最新的 Docker 支持情况,官方文档在这里:https://docs.docker.com/install/。
Docker 对于内核支持的功能,即内核的配置选项也有一定的要求(比如必须开启 Cgroup 和 Namespace 相关选项,以及其他的网络和存储驱动等)。
Docker 源码中提供了一个检测脚本来检测和指导内核的配置,脚本链接在这里:
https://raw.githubusercontent.com/docker/docker/master/contrib/check-config.sh。

在满足前提条件后,安装就变得非常的简单了。
Docker CE 的安装请参考官方文档:MacOS:

https://docs.docker.com/docker-for-mac/install/Windows:https://docs.docker.com/docker-for-windows/install/Ubuntu:https://docs.docker.com/install/linux/docker-ce/ubuntu/Debian:https://docs.docker.com/install/linux/docker-ce/debian/CentOS:https://docs.docker.com/install/linux/docker-ce/centos/Fedora:https://docs.docker.com/install/linux/docker-ce/fedora/其他 Linux 发行版:https://docs.docker.com/install/linux/docker-ce/binaries/

这里我们以 CentOS 7 作为演示。

环境准备:

  • 阿里云服务器(1 核 2G,1M 带宽)
  • CentOS 7.4 64 位
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # 1、yum 包更新到最新 
    yum update
    # 2、安装需要的软件包, yum-util 提供yum-config-manager功能,另外两个是devicemapper驱动依赖的
    yum install -y yum-utils device-mapper-persistent-data lvm2
    # 3、 设置yum源
    yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
    # 4、 安装docker,出现输入的界面都按 y
    yum install -y docker-ce
    # 5、 查看docker版本,验证是否验证成功
    docker -v

安装 Docker

Docker 软件包已经包括在默认的 CentOS-Extras 软件源里。因此想要安装 Docker,只需要运行下面的 yum 命令:
$ sudo yum install docker
当然在测试或开发环境中 Docker 官方为了简化安装流程,提供了一套便捷的安装脚本,CentOS 系统上可以使用这套脚本安装:
curl -fsSL get.docker.com -o get-docker.shsh get-docker.sh
具体可以参看 docker-install 的脚本:https://github.com/docker/docker-install。
执行这个命令后,脚本就会自动的将一切准备工作做好,并且把 Docker CE 的 Edge 版本安装在系统中。
安装完成后,运行下面的命令,验证是否安装成功:docker versionordocker info
返回 Docker 的版本相关信息,证明 Docker 安装成功:
  .png

启动 Docker-CE:

$ sudo systemctl enable docker$ sudo systemctl start docker

Docker 的简单运用 Hello World

由于服务器日常崩溃了, Docker 出了点问题,所以以下案例的演示是基于 Kali Linux 环境下进行的。
我们通过最简单的 Image 文件 Hello World,感受一下 Docker 的魅力吧!
我们直接运行下面的命令,将名为 hello-world 的 image 文件从仓库抓取到本地:

docker pull library/hello-world

docker pull images 是抓取 image 文件,library/hello-world 是 image 文件在仓库里面的位置,其中 library 是 image 文件所在的组,hello-world 是 image 文件的名字。
  .png
抓取成功以后,就可以在本机看到这个 image 文件了:

docker images

我们可以看到如下结果:  .png
现在,我们可以运行 hello-world 这个 image 文件:docker run hello-world我们可以看到如下结果:  .png

输出这段提示以后,hello world 就会停止运行,容器自动终止。有些容器不会自动终止,因为提供的是服务,比如 MySQL 镜像等。
是不是很 Easy 呢?我们从上面可以看出,Docker 的功能是十分强大的,除此之外,我们还可以拉取一些 Ubuntu,Apache 等镜像,在未来的教程中我们将会一一提到。
Docker 提供了一套简单实用的命令来创建和更新镜像,我们可以通过网络直接下载一个已经创建好了的应用镜像,并通过 Docker RUN 命令就可以直接使用。
当镜像通过 RUN 命令运行成功后,这个运行的镜像就是一个 Docker 容器啦。
容器可以理解为一个轻量级的沙箱,Docker 利用容器来运行和隔离应用,容器是可以被启动、停止、删除的,这并不会影响 Docker 镜像。

我们可以看看下面这幅图:  .png
Docker 客户端是 Docker 用户与 Docker 交互的主要方式。当您使用 Docker 命令行运行命令时,Docker 客户端将这些命令发送给服务器端,服务端将执行这些命令。
Docker 命令使用 Docker API 。Docker 客户端可以与多个服务端进行通信。

我们将剖析一下 Docker 容器是如何工作的,学习好 Docker 容器工作的原理,我们就可以自己去管理我们的容器了。

5 Docker 架构

在上面的学习中,我们简单地讲解了 Docker 的基本架构。了解到了 Docker 使用的是 C/S 结构,即客户端/服务器体系结构。
明白了 Docker 客户端与 Docker 服务器进行交互时,Docker 服务端负责构建、运行和分发 Docker 镜像。
知道了 Docker 客户端和服务端可以运行在一台机器上,我们可以通过 RESTful、Stock 或网络接口与远程 Docker 服务端进行通信。

我们从下图可以很直观的了解到 Docker 的架构:
\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZIbpYMxU-1589985834530)(en-resource://database/4435:1)\]

Docker 的核心组件包括:

  • Docker Client
  • Docker Daemon
  • Docker Image
  • Docker Registry
  • Docker Container

Docker 采用的是 Client/Server 架构。客户端向服务器发送请求,服务器负责构建、运行和分发容器。
客户端和服务器可以运行在同一个 Host 上,客户端也可以通过 Socket 或 REST API 与远程的服务器通信。

Docker Client

Docker Client ,也称 Docker 客户端。它其实就是 Docker 提供命令行界面(CLI)工具,是许多 Docker 用户与 Docker 进行交互的主要方式。
客户端可以构建,运行和停止应用程序,还可以远程与 Docker_Host 进行交互。
最常用的 Docker 客户端就是 Docker 命令,我们可以通过 Docker 命令很方便地在 Host 上构建和运行 Docker 容器。  .png

Docker Daemon

Docker Daemon 是服务器组件,以 Linux 后台服务的方式运行,是 Docker 最核心的后台进程,我们也把它称为守护进程。
它负责响应来自 Docker Client 的请求,然后将这些请求翻译成系统调用完成容器管理操作。
该进程会在后台启动一个 API Server ,负责接收由 Docker Client 发送的请求,接收到的请求将通过 Docker Daemon 内部的一个路由分发调度,由具体的函数来执行请求。  .png
我们大致可以将其分为以下三部分:

  • Docker Server
  • Engine
  • Job

Docker Daemon 的架构如下所示:
  .png
Docker Daemon 可以认为是通过 Docker Server 模块接受 Docker Client 的请求,并在 Engine 中处理请求,然后根据请求类型,创建出指定的 Job 并运行。
Docker Daemon 运行在 Docker Host 上,负责创建、运行、监控容器,构建、存储镜像。
运行过程的作用有以下几种可能:

  • 向 Docker Registry 获取镜像。
  • 通过 GraphDriver 执行容器镜像的本地化操作。
  • 通过 NetworkDriver 执行容器网络环境的配置。
  • 通过 ExecDriver 执行容器内部运行的执行工作。

由于 Docker Daemon 和 Docker Client 的启动都是通过可执行文件 Docker 来完成的,因此两者的启动流程非常相似。
Docker 可执行文件运行时,运行代码通过不同的命令行 Flag 参数,区分两者,并最终运行两者各自相应的部分。
启动 Docker Daemon 时,一般可以使用以下命令来完成:

docker –daemon = truedocker –ddocker –d = true

再由 Docker 的 main() 函数来解析以上命令的相应 Flag 参数,并最终完成 Docker Daemon 的启动。
下图可以很直观地看到 Docker Daemon 的启动流程:  .png
默认配置下,Docker Daemon 只能响应来自本地 Host 的客户端请求。如果要允许远程客户端请求,需要在配置文件中打开 TCP 监听。
我们可以照着如下步骤进行配置:

  1. 编辑配置文件/etc/systemd/system/multi-user.target.wants/docker.service,在环境变量 ExecStart 后面添加 -H tcp://0.0.0.0,允许来自任意 IP 的客户端连接。  .png
  2. 重启 Docker Daemon:

    systemctl daemon-reloadsystemctl restart docker.service

  3. 我们通过以下命令即可实现与远程服务器通信:

    docker -H 服务器IP地址 info

    -H 是用来指定服务器主机,info 子命令用于查看 Docker 服务器的信息。

Docker Image

Docker 镜像可以看作是一个特殊的文件系统,除了提供容器运行时所需的程序、库、资源、配置等文件外,还包含了一些为运行时准备的一些配置参数(如匿名卷、环境变量、用户等)。
镜像不包含任何动态数据,其内容在构建之后也不会被改变。我们可将 Docker 镜像看成只读模板,通过它可以创建 Docker 容器。
镜像有多种生成方法:

  • 从无到有开始创建镜像
  • 下载并使用别人创建好的现成的镜像
  • 在现有镜像上创建新的镜像

我们可以将镜像的内容和创建步骤描述在一个文本文件中,这个文件被称作 Dockerfile ,通过执行 docker build命令可以构建出 Docker 镜像。

Docker Registry

Docker Registry 是存储 Docker Image 的仓库,它在 Docker 生态环境中的位置如下图所示:  .png
运行 docker push、docker pull、docker search 时,实际上是通过 Docker Daemon 与 Docker Registry 通信。

Docker Container

Docker 容器就是 Docker 镜像的运行实例,是真正运行项目程序、消耗系统资源、提供服务的地方。

Docker Container 提供了系统硬件环境,我们可以使用 Docker Images 这些制作好的系统盘,再加上我们所编写好的项目代码,Run 一下就可以提供服务啦。

6 Docker 组件是如何协作运行容器

看到这里,我相信各位读者朋友们应该已经对 Docker 基础架构熟悉的差不多了,我们还记得运行的第一个容器吗?
现在我们再通过 hello-world 这个例子来体会一下 Docker 各个组件是如何协作的。
容器启动过程如下:

  • Docker 客户端执行 docker run 命令。
  • Docker Daemon 发现本地没有 hello-world 镜像。
  • Daemon 从 Docker Hub 下载镜像。
  • 下载完成,镜像 hello-world 被保存到本地。
  • Docker Daemon 启动容器。

具体过程可以看如下这幅演示图:  .png
我们可以通过 Docker Images 可以查看到 hello-world 已经下载到本地:  .png
我们可以通过 Docker Ps 或者 Docker Container ls 显示正在运行的容器,我们可以看到,hello-world 在输出提示信息以后就会停止运行,容器自动终止,所以我们在查看的时候没有发现有容器在运行。  .png
我们把 Docker 容器的工作流程剖析的十分清楚了,我们大体可以知道 Docker 组件协作运行容器可以分为以下几个过程:

  • Docker 客户端执行 docker run 命令。
  • Docker Daemon 发现本地没有我们需要的镜像。
  • Daemon 从 Docker Hub 下载镜像。
  • 下载完成后,镜像被保存到本地。
  • Docker Daemon 启动容器。

了解了这些过程以后,我们再来理解这些命令就不会觉得很突兀了,下面我来给大家讲讲 Docker 常用的一些命令操作吧。

7 Docker 常用命令

我们可以通过 docker -h 去查看命令的详细的帮助文档。在这里我只会讲一些日常我们可能会用的比较多的一些命令。  .png
Docker进程相关命令

  • 启动docker服务:
    systemctl start docker
    • 停止docker服务:
      systemctl stop docker
  • 重启docker服务:
    systemctl restart docker
  • 查看docker服务状态:
    systemctl status docker
  • 设置开机启动docker服务:
    systemctl enable docker

Docker 镜像相关命令

  • 查看镜像: 查看本地所有的镜像

    docker images
    docker images –q # 查看所用镜像的id

    • 搜索镜像:从网络中查找需要的镜像

      docker search 镜像名称

    • 拉取镜像:从Docker仓库下载镜像到本地,镜像名称格式为 名称:版本号,如果版本号不指定则是最新的版本。
      如果不知道镜像版本,可以去docker hub 搜索对应镜像查看。

      docker pull 镜像名称

    • 删除镜像: 删除本地镜像

      docker rmi 镜像id # 删除指定本地镜像
      docker rmi docker images -q # 删除所有本地镜像

    Docker容器相关命令
  • 查看容器

    docker ps # 查看正在运行的容器
    docker ps –a # 查看所有容器

    • 创建并启动容器

      docker run 参数

参数说明:
• -i:保持容器运行。通常与 -t 同时使用。加入it这两个参数后,容器创建后自动进入容器中,退出容器后,容器自动关闭。
• -t:为容器重新分配一个伪输入终端,通常与 -i 同时使用。
• -d:以守护(后台)模式运行容器。创建一个容器在后台运行,需要使用docker exec 进入容器。退出后,容器不会关闭。
• -it 创建的容器一般称为交互式容器,-id 创建的容器一般称为守护式容器
• –name:为创建的容器命名。

  • 进入容器

    docker exec 数 参数 # 退出容器,容器不会关闭

  • 停止容器

    docker stop 容器名称

  • 启动容器

    docker start 容器名称

  • 删除容器:如果容器是运行状态则删除失败,需要停止容器才能删除

    docker rm 容器名称

  • 查看容器信息

    docker inspect



例如,我们需要拉取一个 Docker 镜像,我们可以用如下命令:

docker pull

image_nameimage_name 为镜像的名称,而如果我们想从 Docker Hub 上去下载某个镜像,我们可以使用以下命令:

docker pull centos:latest

cento:lastest 是镜像的名称,Docker Daemon 发现本地没有我们需要的镜像,会自动去 Docker Hub 上去下载镜像,下载完成后,该镜像被默认保存到 /var/lib/docker 目录下。
接着我们如果想查看主机下存在多少镜像,我们可以用如下命令:

docker images

我们要想知道当前有哪些容器在运行,我们可以用如下命令:

docker ps -a

-a 是查看当前所有的容器,包括未运行的。我们该如何去对一个容器进行启动,重启和停止呢?
我们可以用如下命令:

docker start container_name/container_id
docker restart container_name/container_id
docker stop container_name/container_id

这个时候我们如果想进入到这个容器中,我们可以使用 attach 命令:

docker attach container_name/container_id

那如果我们想运行这个容器中的镜像的话,并且调用镜像里面的 bash ,我们可以使用如下命令:

docker run -t -i container_name/container_id /bin/bash

那如果这个时候,我们想删除指定镜像的话,由于 Image 被某个 Container 引用(拿来运行),如果不将这个引用的 Container 销毁(删除),那 Image 肯定是不能被删除。
我们首先得先去停止这个容器:

docker ps
docker stop container_name/container_id

然后我们用如下命令去删除这个容器:

docker rm container_name/container_id

然后这个时候我们再去删除这个镜像:

docker rmi image_name

此时,常用的 Docker 相关的命令就讲到这里为止了,我们在后续的文章中还会反复地提到这些命令。

Docker容器的数据卷

概念

  • 数据卷是宿主机中的一个目录或文件
  • 当容器目录和数据卷目录绑定后,对方的修改会立即同步
  • 一个数据卷可以被多个容器同时挂载
  • 一个容器也可以被挂载多个数据卷

    作用

  • 容器数据持久化
  • 外部机器和容器间接通信
  • 容器之间数据交换

    配置数据卷

    • 创建启动容器时,使用 –v 参数 设置数据卷
      docker run … –v 宿主机目录( 文件): 容器内目录( 文件) …
  • 注意事项:
  1. 目录必须是绝对路径
  2. 如果目录不存在,会自动创建
  3. 可以挂载多个数据卷
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YWasWMCg-1589985834540)(en-resource://database/4441:1)\]

    数据卷容器

    多容器进行数据交换
  4. 多个容器挂载同一个数据卷
  5. 数据卷容器
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wA9DAtQY-1589985834541)(en-resource://database/4443:1)\]

    配置数据卷容器

  6. 创建启动c3数据卷容器,使用 –v 参数 设置数据卷

    docker run –it –name=c3 –v /volume centos:7 /bin/bash

  7. 创建启动 c1 c2 容器,使用 –-volumes-from 参数 设置数据卷

    docker run –it –name=c1 –volumes-from c3 centos:7 /bin/bash
    docker run –it –name=c2 –volumes-from c3 centos:7 /bin/bash

    数据卷小结

  8. 数据卷概念
    • 宿主机的一个目录或文件
  9. 数据卷作用
    • 容器数据持久化
    • 客户端和容器数据交换
    • 容器间数据交换
  10. 数据卷容器
    • 创建一个容器,挂载一个目录,让其他容器继承自该容器( –volume-from )。
    • 通过简单方式实现数据卷配置

Docker 应用部署

一、部署MySQL

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PkehUSZH-1589985834543)(en-resource://database/4445:1)\]

  1. 搜索mysql镜像
1
docker search mysql
  1. 拉取mysql镜像
1
docker pull mysql:5.6
  1. 创建容器,设置端口映射、目录映射
1
2
3
# 在/root目录下创建mysql目录用于存储mysql数据信息
mkdir ~/mysql
cd ~/mysql
1
2
3
4
5
6
7
8
docker run -id \
-p 3306:3306 \
--name=c_mysql \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:5.6
  • 参数说明:
    • -p 3306:3306:将容器的 3306 端口映射到宿主机的 3306 端口。
    • -v $PWD/conf:/etc/mysql/conf.d:将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置目录
    • -v $PWD/logs:/logs:将主机当前目录下的 logs 目录挂载到容器的 /logs。日志目录
    • -v $PWD/data:/var/lib/mysql :将主机当前目录下的data目录挂载到容器的 /var/lib/mysql 。数据目录
    • -e MYSQL_ROOT_PASSWORD=123456:初始化 root 用户的密码。
  1. 进入容器,操作mysql
1
docker exec –it c_mysql /bin/bash
  1. 使用外部机器连接容器中的mysql

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OPR6tavj-1589985834544)(en-resource://database/4447:1)\]

二、部署Tomcat

  1. 搜索tomcat镜像
1
docker search tomcat
  1. 拉取tomcat镜像
1
docker pull tomcat
  1. 创建容器,设置端口映射、目录映射
1
2
3
# 在/root目录下创建tomcat目录用于存储tomcat数据信息
mkdir ~/tomcat
cd ~/tomcat
1
2
3
4
docker run -id --name=c_tomcat \
-p 8080:8080 \
-v $PWD:/usr/local/tomcat/webapps \
tomcat
  • 参数说明:

    • -p 8080:8080:将容器的8080端口映射到主机的8080端口

      -v $PWD:/usr/local/tomcat/webapps:将主机中当前目录挂载到容器的webapps

  1. 使用外部机器访问tomcat

三、部署Nginx

  1. 搜索nginx镜像
1
docker search nginx
  1. 拉取nginx镜像
1
docker pull nginx
  1. 创建容器,设置端口映射、目录映射
1
2
3
4
5
6
7
# 在/root目录下创建nginx目录用于存储nginx数据信息
mkdir ~/nginx
cd ~/nginx
mkdir conf
cd conf
# 在~/nginx/conf/下创建nginx.conf文件,粘贴下面内容
vim nginx.conf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

user nginx;
worker_processes 1;

error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;


events {
worker_connections 1024;
}


http {
include /etc/nginx/mime.types;
default_type application/octet-stream;

log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';

access_log /var/log/nginx/access.log main;

sendfile on;
#tcp_nopush on;

keepalive_timeout 65;

#gzip on;

include /etc/nginx/conf.d/*.conf;
}
1
2
3
4
5
6
docker run -id --name=c_nginx \
-p 80:80 \
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf \
-v $PWD/logs:/var/log/nginx \
-v $PWD/html:/usr/share/nginx/html \
nginx
  • 参数说明:
    • -p 80:80:将容器的 80端口映射到宿主机的 80 端口。
    • -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf:将主机当前目录下的 /conf/nginx.conf 挂载到容器的 :/etc/nginx/nginx.conf。配置目录
    • -v $PWD/logs:/var/log/nginx:将主机当前目录下的 logs 目录挂载到容器的/var/log/nginx。日志目录
  1. 使用外部机器访问nginx
    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rJZLH2VX-1589985834545)(en-resource://database/4449:1)\]

四、部署Redis

  1. 搜索redis镜像
1
docker search redis
  1. 拉取redis镜像
1
docker pull redis:5.0
  1. 创建容器,设置端口映射
1
docker run -id --name=c_redis -p 6379:6379 redis:5.0
  1. 使用外部机器连接redis
1
./redis-cli.exe -h 192.168.149.135 -p 6379

Dockerfile

Docker镜像原理

Linux文件系统由bootfs和rootfs两部分组成

  • bootfs:包含bootloader(引导加载程序)和 kernel(内核)
  • rootfs: root文件系统,包含的就是典型 Linux 系统中的/dev,/proc,/bin,/etc等标准目录和文件
  • 不同的linux发行版,bootfs基本一样,而rootfs不同,如ubuntu,centos等

  • Docker镜像是由特殊的文件系统叠加而成
  • 最底端是 bootfs,并使用宿主机的bootfs
  • 第二层是 root文件系统rootfs,称为base image
  • 然后再往上可以叠加其他的镜像文件
  • 统一文件系统(Union File System)技术能够将不同的层整合成一个文件系统,为这些层提供了一个统一的视角,这样就隐藏了多层的存在,在用户的角度看来,只存在
    一个文件系统。
  • 一个镜像可以放在另一个镜像的上面。位于下面的镜像称
    为父镜像,最底部的镜像成为基础镜像。
  • 当从一个镜像启动容器时,Docker会在最顶层加载一个读
    写文件系统作为容器

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FRtWHHmZ-1589985834545)(en-resource://database/4453:1)\]
思考:

  1. Docker 镜像本质是什么?
    • 是一个分层文件系统

  2. Docker 中一个centos镜像为什么只有200MB,而一个centos操作系统的iso文件要几个个G?
    • Centos的iso镜像文件包含bootfs和rootfs,而docker的centos镜像复用操作系统的bootfs,只有rootfs和其他镜像层

  3. Docker 中一个tomcat镜像为什么有500MB,而一个tomcat安装包只有70多MB?
    • 由于docker中镜像是分层的,tomcat虽然只有70多MB,但他需要依赖于父镜像和基础镜像,所有整个对外暴露的
    tomcat镜像大小500多MB

    镜像制作

    \[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gH7Y7XQ3-1589985834546)(en-resource://database/4455:1)\]

  4. 容器转为镜像

    docker commit 容器id 镜像名称: 版本号
    docker save -o 称 压缩文件名称 镜像名称: 版本号
    docker load –i 压缩文件名称

  5. dockerfile

dockerfile概念

  • Dockerfile 是一个文本文件
  • 包含了一条条的指令
  • 每一条指令构建一层,基于基础镜像,最终构建出一个新的镜像
  • 对于开发人员:可以为开发团队提供一个完全一致的开发环境
  • 对于测试人员:可以直接拿开发时所构建的镜像或者通过Dockerfile文件
    构建一个新的镜像开始工作了
  • 对于运维人员:在部署时,可以实现应用的无缝移植
关键字 作用 备注
FROM 指定父镜像 指定dockerfile基于那个image构建
MAINTAINER 作者信息 用来标明这个dockerfile谁写的
LABEL 标签 用来标明dockerfile的标签 可以使用Label代替Maintainer 最终都是在docker image基本信息中可以查看
RUN 执行命令 执行一段命令 默认是/bin/sh 格式: RUN command 或者 RUN [“command” , “param1”,”param2”]
CMD 容器启动命令 提供启动容器时候的默认命令 和ENTRYPOINT配合使用.格式 CMD command param1 param2 或者 CMD [“command” , “param1”,”param2”]
ENTRYPOINT 入口 一般在制作一些执行就关闭的容器中会使用
COPY 复制文件 build的时候复制文件到image中
ADD 添加文件 build的时候添加文件到image中 不仅仅局限于当前build上下文 可以来源于远程服务
ENV 环境变量 指定build时候的环境变量 可以在启动的容器的时候 通过-e覆盖 格式ENV name=value
ARG 构建参数 构建参数 只在构建的时候使用的参数 如果有ENV 那么ENV的相同名字的值始终覆盖arg的参数
VOLUME 定义外部可以挂载的数据卷 指定build的image那些目录可以启动的时候挂载到文件系统中 启动容器的时候使用 -v 绑定 格式 VOLUME [“目录”]
EXPOSE 暴露端口 定义容器运行的时候监听的端口 启动容器的使用-p来绑定暴露端口 格式: EXPOSE 8080 或者 EXPOSE 8080/udp
WORKDIR 工作目录 指定容器内部的工作目录 如果没有创建则自动创建 如果指定/ 使用的是绝对地址 如果不是/开头那么是在上一条workdir的路径的相对路径
USER 指定执行用户 指定build或者启动的时候 用户 在RUN CMD ENTRYPONT执行的时候的用户
HEALTHCHECK 健康检查 指定监测当前容器的健康监测的命令 基本上没用 因为很多时候 应用本身有健康监测机制
ONBUILD 触发器 当存在ONBUILD关键字的镜像作为基础镜像的时候 当执行FROM完成之后 会执行 ONBUILD的命令 但是不影响当前镜像 用处也不怎么大
STOPSIGNAL 发送信号量到宿主机 该STOPSIGNAL指令设置将发送到容器的系统调用信号以退出。
SHELL 指定执行脚本的shell 指定RUN CMD ENTRYPOINT 执行命令的时候 使用的shell
### dockerfile案例
案例:需求
自定义centos7镜像。要求:
1. 默认登录路径为 /usr
2. 可以使用vim

案例:实现步骤
① 定义父镜像:FROM centos:7
② 定义作者信息:MAINTAINER itheima itheima@itcast.cn
③ 执行安装vim命令: RUN yum install -y vim
④ 定义默认的工作目录:WORKDIR /usr
⑤ 定义容器启动执行的命令:CMD /bin/bash
⑥ 通过dockerfile构建镜像:docker bulid –f dockerfile文件路径 –t 镜像名称:版本


案例:需求
定义dockerfile,发布springboot项目
案例:实现步骤
① 定义父镜像:FROM java:8
② 定义作者信息:MAINTAINER itheima itheima@itcast.cn
③ 将jar包添加到容器: ADD springboot.jar app.jar
④ 定义容器启动执行的命令:CMD java–jar app.jar
⑤ 通过dockerfile构建镜像:docker bulid –f dockerfile文件路径 –t 镜像名称:版本

Docker服务编排

概念

微服务架构的应用系统中一般包含若干个微服务,每个微服务一般都会部署多个实例,如果每个微服务都要手动启停,维护的工作量会很大。
• 要从Dockerfile build image 或者去dockerhub拉取image
• 要创建多个container
• 要管理这些container(启动停止删除)
服务编排: 按照一定的业务规则批量管理容器

Docker Compose

Docker Compose是一个编排多容器分布式部署的工具,提供命令集管理容器化应用的完整开发周期,包括服务构建,启动和停止。使用步骤:

  1. 利用 Dockerfile 定义运行环境镜像
  2. 使用 docker-compose.yml 定义组成应用的各服务
  3. 运行 docker-compose up 启动应用

    一、安装Docker Compose

1
2
3
4
5
6
# Compose目前已经完全支持Linux、Mac OS和Windows,在我们安装Compose之前,需要先安装Docker。下面我 们以编译好的二进制包方式安装在Linux系统中。 
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
# 设置文件可执行权限
chmod +x /usr/local/bin/docker-compose
# 查看版本信息
docker-compose -version

二、卸载Docker Compose

1
2
# 二进制包方式安装的,删除二进制文件即可
rm /usr/local/bin/docker-compose

三、 使用docker compose编排nginx+springboot项目

  1. 创建docker-compose目录
1
2
mkdir ~/docker-compose
cd ~/docker-compose
  1. 编写 docker-compose.yml 文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
version: '3'
services:
nginx:
image: nginx
ports:
- 80:80
links:
- app
volumes:
- ./nginx/conf.d:/etc/nginx/conf.d
app:
image: app
expose:
- "8080"
  1. 创建./nginx/conf.d目录
1
mkdir -p ./nginx/conf.d
  1. 在./nginx/conf.d目录下 编写itheima.conf文件
1
2
3
4
5
6
7
8
9
server {
listen 80;
access_log off;

location / {
proxy_pass http://app:8080;
}

}
  1. 在~/docker-compose 目录下 使用docker-compose 启动容器
1
docker-compose up
  1. 测试访问
1
http://192.168.149.135/hello

Docker私有仓库

概念

Docker官方的Docker hub(https://hub.docker.com)是一个用于管理公共镜像的仓库,我们可以从上面拉取镜像到本地,也可以把我们自己的镜像推送上去。但是,有时候我们的服务器无法访问互联网,或者你不希望将自己的镜像放到公网当中,那么我们就需要搭建自己的私有仓库来存储和管理自己的镜像。

搭建私有仓库

1
2
3
4
5
6
7
8
9
10
11
12
# 1、拉取私有仓库镜像 
docker pull registry
# 2、启动私有仓库容器
docker run -id --name=registry -p 5000:5000 registry
# 3、打开浏览器 输入地址http://私有仓库服务器ip:5000/v2/_catalog,看到{"repositories":[]} 表示私有仓库 搭建成功
# 4、修改daemon.json
vim /etc/docker/daemon.json
# 在上述文件中添加一个key,保存退出。此步用于让 docker 信任私有仓库地址;注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip
{"insecure-registries":["私有仓库服务器ip:5000"]}
# 5、重启docker 服务
systemctl restart docker
docker start registry

上传镜像到私有仓库

1
2
3
4
5
# 1、标记镜像为私有仓库的镜像     
docker tag centos:7 私有仓库服务器IP:5000/centos:7

# 2、上传标记的镜像
docker push 私有仓库服务器IP:5000/centos:7

从私有仓库拉取镜像

1
2
#拉取镜像 
docker pull 私有仓库服务器ip:5000/centos:7

Docker 容器虚拟化与传统虚拟机比较

容器就是将软件打包成标准化单元,以用于开发、交付和部署。
• 容器镜像是轻量的、可执行的独立软件包 ,包含软件运行所需的所有内容:代码、运行时环境、系统工具、系统库和设置。
• 容器化软件在任何环境中都能够始终如一地运行。
• 容器赋予了软件独立性,使其免受外在环境差异的影响,从而有助于减少团队间在相同基础设施上运行不同软件时的冲突。
在这里插入图片描述
相同:
• 容器和虚拟机具有相似的资源隔离和分配优势
不同:
• 容器虚拟化的是操作系统,虚拟机虚拟化的是硬件。
• 传统虚拟机可以运行不同的操作系统,容器只能运行同一类型操作系统


2020年5月20日更