Docker与微服务实战(2022版)

1、基础篇(零基础小白)

1.1、Docker简介

1.1.1、怎么去学习Docker

学习前的思路：

1.是什么

2.能干什么

3.去哪里下

4.怎么用

5.跑起来

1.1.2、是什么

1.1.2.1、为什么会有docker的出现？

没有Docker之前，从开发环境到测试环境再到运维的生产环境，容易出现本地开发没问题，到了测试和生产环境就出现不同程度的问题，这是由于开发人员自己电脑的环境各有不同，你开发的应用还要依赖某些配置文件，没有统一的标准，部署时需要安装不同的环境，扩容时需要新增一个容器，需要新装环境，扩容缩容都非常麻烦。有了Docker容器，就相当于有了一个标准化的解决方案，系统平滑移植，容器虚拟化技术。Docker可以把开发人员电脑里面的环境一模一样的复制一份放在服务器上，消除了不同应用环境不同的问题，开发在打包时将源码+配置+环境+版本打包成一个镜像文件放入到Docker容器里面。

1.1.2.2、docker理念

类比：VMware+centos7.iso => docker+gmall.镜像文件

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

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

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

1.1.2.3、为什么使用Docker？

为什么使用Docker？
①更轻量：基于容器的虚拟化，仅包含业务运行所需的runtime环境，CentOS/Ubuntu基础镜像仅170M;宿主机可部署100~1000个容器
②更高效：无操作系统虚拟化开销计算:轻量,无额外开销
存储：系统盘aufs/dmVoverlayfs;数据盘volume
网络：宿主机网络，NS隔离
③更敏捷、更灵活：
分层的存储和包管理,devops理念
支持多种网络配置

1.1.2.3、总结

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

1.1.3、容器与虚拟机比较

1.1.3.1、容器发展简史

安装构建发展史：磁盘 -> 器械 -> 虚拟机 -> docker

docker可以存放静态网站、数据库、前端、消息中间件队列、动态数据源等。

1.1.3.2、传统虚拟机技术

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

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

传统虚拟机技术基于安装在主操作系统上的虚拟机管理系统(如: VirtualBox和VMWare等)，创建虚拟机(虚拟出各种硬件)，在虚拟机上安装从操作系统，在从
操作系统中安装部署各种应用。-

虚拟机的缺点:①资源占用多；②冗余步骤多；③启动慢；

1.1.3.3、容器虚拟化技术

由于前面虚拟机存在某些缺点，Linux发展出了另一种虚拟化技术:

Linux容器(Linux Containers，缩写为LXC)
Linux容器是与系统其他部分隔离开的一系列进程，从另一个镜像运行，并由该镜像提供支持进程所需的全部文件。容器提供的镜像包含了应用的所有依赖项，因而在从开发到测试再到生产的整个过程中，它都具有可移植性和一致性。

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

Docker容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统虚拟机则是在硬件层面实现虚拟化。与传统的虚拟机相比，Docker优势体现为启动速度快、占用体积小。

1.1.3.4、对比

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

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

1.1.4、能干嘛

1.1.4.1、技术职级变化

coder(编码) -> programmer(程序员) -> software enginner(软件工程师) -> DevOps enginner(开发/运维工程师)

1.1.4.2、开发/运维(DevOps)新一代开发工程师

一次构建、随处运行：

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

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

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

④更高效的计算资源利用
Docker是内核级虚拟化，其不像传统的虚拟化技术一样需要额外的Hypervisor支持，所以在一台物理机上可以运行很多个容器实列，可大大提升物理服务器的CPU和内存的利用率。

1.1.4.2.1、Docker的应用场景

Docker借鉴了标准集装箱的概念。标准集装箱将货物运往世界各地，Docker将这个模型运用到自己的设计中，唯一不同的是:集装箱运输货物，而Docker运输软件。

1.1.4.3、哪些企业在使用

新浪、美团、蘑菇街、、、、

1.1.5、哪里下

1.1.5.1、官网

docker官网

Docker Hub官网:安装docker镜像的仓库

1.2、Docker安装

1.2.1、前提说明

Centos Docker安装

Docker并非是一个通用的容器工具，它依赖于已存在并运行的Linux内核环境。
Docker实质上是在已经运行的Linux下制造了一个隔离的文件环境，因此它执行的效率几乎等同于所部署的Linux主机。因此，Docker必须部署在Linux内核的系统上。如果其他系统想部署Docker就必须安装一个虚拟Linux环境。
在Windows上部署Docker的方法都是先安装一个虚拟机，并在安装Linux系统的的虚拟机中运行Docker。

前提条件

目前，CentOS仅发行版本中的内核支持Docker。Docker运行在CentOS 7(64-bit)上，要求系统为64位、Linux系统内核版本为3.8以上，这里选用Centos7.x。

查看自己的内核

uname命令用于打印当前系统相关信息(内核版本号、硬件架构、主机名称和操作系统类型等）。
[ root@zzyy ~]# cat /etc/redhat- release
centos Linux release 7.4.1708 ( core)
[root@zzyy ~]#
[root@zzyy ~]# uname - r
3.10.o- 693.el7.x86_64
[root@zzyy ~]#

1.2.2、Docker的基本组成

1.2.2.2、Docker三件套

镜像(image)

Docker镜像（lmage）就是一个只读的模板。镜像可以用来创建Docker容器,一个镜像可以创建很多容器。
它也相当于是一个root文件系统。比如官方镜像centos:7 就包含了完整的一套centos:7最小系统的 root文件系统。
相当于容器的“源代码”，docker镜像文件类似于Java的类模板，而docker容器实例类似于java中new出来的实例对象。
容器与镜像的关系类型于面向对象编程中的对象与类：
Docker->容器、镜像；面向对象->对象、类；

容器(container)

①从面向对象角度
Docker利用容器〈Container)独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境,它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

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

仓库(repository)

仓库（Repository）是集中存放镜像文件的场所。
类似于
Maven仓库，存放各种jar包的地方;
github仓库，存放各种git项目的地方;
Docker公司提供的官方registry被称为DocKer Hub，存放各种镜像模板的地方。
仓库分为公开仓库（Public）和私有仓库（Private）两种形式。
最大的公开仓库是Docker Hub(https://hub.docker.com/)，
存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等

小总结

需要正确的理解仓库/镜像/容器这几个概念:
Docker本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就是image镜像文件。只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。
image文件可以看作是容器的模板。Docker根据 image文件生成容器的实例。同一个image文件，可以生成多个同时运行的容器实例。
镜像文件
*image 文件生成的容器实例，本身也是一个文件，称为镜像文件。
容器实例
一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器
仓库
*就是放一堆镜像的地方，我们可以把镜像发布到仓库中，需要的时候再从仓库中拉下来就可以了。

1.2.2.2、Docker平台架构图解(入门版)

1.2.2.2.1、架构图解#####

Client 客户端；DOCKER_HOST Docker宿主机；Docker daemon Docker引擎；Containers Docker容器；Images 镜像；Registry 仓库；

1.2.2.2.2、Docker工作原理#####

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

1.2.3、Docker平台架构图解(架构版)###

1.2.3.1、整体架构及底层通信原理简述

Docker是一个C/S模式的架构，后端是一个松耦合架构，众多模块各司其职。
Docker运行的基本流程为:
1.用户是使用Docker Client与 Docker Daemon建立通信，并发送请求给后者。
2.Docker Daemon作为Docker架构中的主体部分，首先提供 Docker Server的功能使其可以接受Docker Client 的请求。
3.Docker Engine 执行Docker内部的一系列工作，每一项工作都是以一个Job的形式的存在。
4.Job的运行过程中，当需要容器镜像时，则从Docker Registy 中下载镜像，并通过镜像管理驱动Graph driver将下载镜像以Graph的形式存储。
5.当需要为Docker创建网络环境时，通过网络管理驱动Network driver创建并配置Docker容器网络环境。
6.当需要限制Docker容器运行资源或执行用户指令等操作时，则通过Exec driver来完成。
7.Libcontainer是一项独立的容器管理包，Network driver以及Exec driver都是通过Libcontainer来实现具体对容器进行的操作。

1.2.4、Docker安装步骤###

注意：下面所有linux命令中，如果你发现有的命令前面加了 sudo，这是使用管理员的权限来进行安装，你如果是管理员账户不加 sudo 也可以。

1.2.4.1、Centos7安装Docker

地址：https://docs.docker.com/engine/install/centos/

1.2.4.1.1、具体安装步骤

1.确定你是CentOS7及以上版本

cat /etc/redhat-release

2.卸载旧版本

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

3.yum安装gcc相关

# 确保CentOS7能上网
# 安装编译环境
yum -y install gcc
yum -y install gcc-c++

4.安装需要的软件包

sudo yum install -y yum-utils

5.设置stable镜像仓库

# 采用下面第二个命令，此命令连接国外的仓库，容易出现网络错误(Errno 14\Errno 12)
# 官网国外的仓库:不推荐
sudo yum-config-manager \
 --add-repo \
 https://download.docker.com/linux/centos/docker-ce.repo
# 阿里云、网易云仓库:推荐
sudo yum-config-manager \
 --add-repo \
 https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

6.更新yum软件包索引

yum makecache fast

7.安装DOCKER CE

# 安装最新版本(指定版本 例如: docker-ce: - docker-ce-18.09.1)
sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin

8.启动Docker

sudo systemctl start docker

# 查看docker进程
ps -ef|grep docker
# 查看docker版本
docker version

9.测试

# 启动hello-world镜像(首次运行可能找不到，它会自己去镜像仓库拉一个)
sudo docker run hello-world

10.卸载

# 停止Docker服务
sudo systemctl stop docker

# 卸载 Docker Engine、CLI、containerd 和 Docker Compose 软件包
sudo yum remove docker-ce docker-ce-cli containerd.io docker-compose-plugin docker-ce-rootless-extras

# 删除所有镜像、容器和仓库
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

1.2.5、阿里云镜像加速

也可以采用网易云、华为云等

1.2.5.1、是什么

地址：https://promotion.aliyun.com/ntms/act/kubernetes.html

注册一个属于自己的阿里云账号(可以复用支付宝淘宝账号)

1.2.5.2、获取一个加速连接地址

可以直接搜索容器镜像服务，也可以通过下面路径寻找。

路径：弹性计算 -> 容器镜像服务 -> 镜像工具 -> 镜像加速器

注意：一定要配置自己的不要直接采用本图片地址

1.2.5.3、粘贴脚本执行并重启docker

找到阿里云当前页面下方CentOS里面的命令复制执行

注意：也可以直接修改daemon配置文件 /etc/docker/daemon.json 使用阿里云镜像加速

# 创建文件夹
sudo mkdir -p /etc/docker

# 配置阿里云镜像加速(每个人使用的加速地址不同，将下面的加速地址更换为自己的阿里云镜像加速地址)
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://3a17pv1d.mirror.aliyuncs.com"]
}
EOF

# 重启daemon
sudo systemctl daemon-reload

# 重启docker服务
sudo systemctl restart docker

# 测试启动hello-world镜像
sudo docker run hello-world

1.2.5.4、docker run到底干了什么

第一步：本地查找镜像，如果找到了直接运行，如果没找到进行第二步；

第二步：在镜像仓库去拉一个镜像，拉到本地运行。

注意：这里前面配置了阿里云镜像，就不会从Docker Hub上去找镜像了，就会从 阿里云镜像 上寻找下载镜像。>

1.2.5.5、Docker底层原理

为什么Docker会比VM虚拟机快？

(1)docker有着比虚拟机更少的抽象层
由于docker不需要Hypervisor(虚拟机)实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
(2)docker利用的是宿主机的内核,而不需要加载操作系统OS内核
当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。进而避免引寻、加载操作系统内核返回等比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载OS,返回新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返回过程,因此新建一个docker容器只需要几秒钟。

	Docker容器	虚拟机（VM）
操作系统	与宿主机共享OS	宿主机OS上运行虚拟机OS
存储大小	镜像小，便于存储和传输	镜像庞大（vmdk、vdi等）
运行性能	几乎无额外性能损失	操作系统额外的CPU、内存损耗
移植性	轻便、灵活，适应于Linux	笨重，与虚拟技术耦合度高
硬件亲和性	面向软件开发者	面向硬件运维者
部署速度	快速，秒级	较慢，10秒以上

1.3、Docker常用命令

1.3.1、帮助启动类命令

# 启动docker
systemctl start docker

# 停止docker
systemctl stop docker

# 重启docker 
ststemctl restart docker

# 查看docker状态(active 活动状态;inactive 失活状态)
systemctl status docker

# 开机启动
systemctl enable docker

# 查看docker概要信息
docker info

# 查看docker总体帮助文档
docker --help

#查看docker命令帮助文档
docker 具体命令 --help

1.3.2、镜像命令

# 列出本地主机上的镜像
docker images [OPTIONS]

OPTIONS说明：
-a：列出本地所有的镜像(含历史镜像层)
-q：只显示镜像ID
-qa ：合并使用上面两个

表头各项说明：
REPOSITORY：表示镜像仓库源
TAG：镜像标签版本号
IMAGE ID：镜像ID
CREATED：镜像创建时间
SIZE：镜像大小

注意：同一仓库源可以有多个TAG版本，代表这个仓库源的不同个版本，我们使用REPOSITORY:TAG来定义不同的镜像。如果你不指定一个镜像的版本标签，例如你只使用ubuntu，docker将默认使用ubuntu:latest镜像

# 搜索云仓库相关镜像(默认是docker Hub，这里配置了阿里云就会从阿里云镜像仓库获取，下面的都是一样)
docker search [某个xxx镜像的名字] [OPTIONS]

OPTIONS说明：
–limit：只列出N个镜像，默认25个
例：docker search --limit 5 redis (只查询5个redis的镜像)

表头各项说明：
NAME：镜像名称
DESCRIPTION：镜像说明
STARS：点赞数量
OFFICAL：是否是官方的
AUTOMATED：是否是自动构建

# 从云仓库拉取镜像到本地
docker pull [某个xxx镜像名字] [:TAG]

注意：没有TAG版本号就默认拉取最新版本(latest 表示最新版本号)

例：docker pull redis:6.0.8(拉取6.0.8版本的redis镜像)

# 查看镜像/容器/数据券所占用的空间
docker system df

表头各项说明：
TYPE：类型(Images 镜像；Containers 容器；Local Volums 本地券；Build Cache 构建缓存)
TOTAL：总数
ACTIVE：活动的数量
SIZE：大小
RECLAIMABLE：可回收的

# 删除本地镜像
docker rmi [某个xxx镜像名称ID]

# 删除单个镜像 -f:强制删除
docker rmi -f [镜像ID]
# 删除多个镜像
docker rmi -f [镜像名1]:TAG [镜像名2]:TAG
#删除全部镜像
docker rmi -f $(docker images -qa)

面试题：谈谈docker虚悬镜像是什么？

是什么：仓库名、标签都是的镜像，俗称虚悬镜像dangling image
长什么样：
产生原因：①构建时候因为编写错误导致；②删除的时候；
操作：对于这样的虚悬镜像一定要删除。

1.3.3、容器命令###

有镜像才能创建容器，这是根本前提(下载一个centos或者ubuntu镜像演示)这里在docker里面安装一个最新版的Ubuntu镜像进行演示操作，Ubuntu镜像比较小只有70多兆

1.3.3.1、新建启动容器

# 使用run关键词来生成实例
docker run [OPTIONS] IMAGE [COMMAND][ARG...]

OPTIONS说明：有些是一个减号，有些是两个减号
–name=容器新名字：为容器指定一个新名称；
-d：后台运行并返回容器ID，也即启动守护式容器(后台运行)；
-i：以交互模式运行容器，通常与t同时使用 -it;
-t：为容器重新分配一个伪输入终端，通常与-i同时使用;
也即启动交互式容器(前台有伪终端，等待交互);
例如：使用镜像ubuntu:latest以交互模式启动一个容器,在容器内执行/bin/bash命令。

docker run -it ubuntu:latest /bin/bash
返回了一个容器ID
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pMUpROgL-1676365398752)(D:\Tools\学习资料\照片\文档图片\image-20230129142442265.png)]

参数说明
-i:交互式操作。
-t:终端。
ubuntu:ubuntu镜像，centos镜像同理。
/bin/bash:放在镜像名后的是命令，这里我们希望有个交互式Shell，因此用的是/bin/bash。要退出终端，直接输入exit:

-P：随机端口映射，大写P
-p：指定端口映射，小写p

参数	说明
-p hostPort:containerPort	端口映射 -p 8080:80
-p ip:hostPort:containerPort	配置监听地址 -p 10.0.0.100:8080:80
-p ip:hostPort	随机分配端口 -p 10.0.0.100::80
-p hostPort:containerPort:udp	指定协议 -p 8080:80:tcp
-p 81:80 -p443:443	指定多个

1.3.3.2、列出当前所有运行的容器

# 列出当前所有运行的容器
docker ps [OPTIONS]

OPTIONS参数说明(常用)：
-a：列出当前所有正在运行的容器+历史上运行过的
-I：显示最近创建的容器。
-n：显示最近n个创建的容器 docker ps -n 2。
-q：静默模式，只显示容器编号。

1.3.3.3、退出容器

# run关键词进入容器，使用exit退出，容器停止
exit

# run关键词进入容器，ctrl+p+q退出，容器不停止
ctrl+p+q

1.3.3.4、启动已停止运行的容器

# 启动已停止的容器
docker run [容器ID或者容器名]

1.3.3.5、重启容器

# 重启容器
docker restart 容器ID或者容器名

1.3.3.6、停止容器

# 停止容器
docker stop 容器ID或者容器名

1.3.3.7、强制停止容器

# 强制停止容器
docker kill 容器ID或者容器名

1.3.3.8、删除已停止的容器

# 删除已停止的容器，注意`docker rmi`是删除镜像
docker rm 容器ID

#一次性删除多个容器实例 -f 强制删除 $()替换命令
docker rm -f $(docker ps -a -q)
或者使用管道符 xargs 可变参数
docker ps -a -q | xargs docker rm

1.3.3.9、重点部分

1.3.3.9.1、下载容器和启动守护式容器

有镜像才能创建容器，这是根本前提(下载一个Redis6.0.8镜像演示)

启动守护式容器(后台服务器)
在大部分的场景下，我们希望docker的服务是在后台运行我们可以过-d指定容器的后台运行模式。

# 后台运行模式(启动守护式容器)启动redis容器
docker run -d [容器名]

## 解释说明
#使用镜像centos:latest以后台模式启动一个容器
docker rgn -d centos

问题:然后docker ps -a进行查看，会发现`容器已经退出`
很重要的要说明的一点: `Docker容器后台运行,就必须有一个前台进程.``
容器运行的命令如果不是那些`一直挂起的命令`（比如运行top，tail)，就是会自动退出的。
这个是docker的机制问题,比如你的web容器,我们以nginx为例，正常情况下，
我们配置启动服务只需要启动响应的service即可。例如service nginx start.
但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用，这样的容器后台启动后,会立即自杀因为他觉得他没事可做了.
所以，最佳的解决方案是,`将你要运行的程序以前台进程的形式运行，常见就是命令行模式，表示我还有交互操作，别中断，o(n_n)O哈哈~`

redis前后台启动演示

# 前台交互式启动
docker run -it --name=redis01 redis:6.0.8

# 后台守护式启动
docker run -d --name=redis01 redis:6.0.8

1.3.3.9.2、查看容器日志

# 查看容器日志
docker logs [容器ID]

1.3.3.9.3、查看容器内运行的进程

# 查看容器内运行的进程
docker top [容器ID]

1.3.3.9.4、查看容器内部细节

# 查看容器内部细节
docker inspect 容器ID

1.3.3.9.5、进入正在运行的容器并以命令行交互(重要)

#进入正在运行的容器并以命令行交互(推荐使用第一个)
docker exec -it [容器ID] /bin/bash 
或者
docker attach [容器ID] /bin/bash 

exec与attach的区别
attach 直接进入容器启动命令的终端，不会启动新的进程用exit退出，会导致容器的停止。
exec是在容器中打开新的终端，并且可以启动新的进程用exit退出，不会导致容器的停止。

1.3.3.9.6、从容器内拷贝文件到主机上

# 从容器内拷贝文件到主机上 容器->主机
docker cp [容器ID]:[容器内路径] [目的主机路径]

1.3.3.9.6、导入和导出容器

# export导出容器的内容留作为一个tar归档文件[对应import命令]
docker export [容器ID]>[文件名].tar

# import 从tar包中的内容创建一个新的文件系统再导入为镜像[对应export]
cat [文件名].tar|docker import -[镜像用户]/[镜像名]:[镜像版本号] 

注意：导出的.tar文件就在当前操作目录下，导入的镜像用户可以随便写

1.3.4、常用命令小总结

#当前shell 下attach 连接指定运行镜像
attach #Attach to a running container

#通过Dockerfile定制镜像
build #Build an image from a Dockerfile

 #提交当前容器为新的镜像
commit #Create a new image from a container changes

#从容器中拷贝指定文件或者目录到宿主机中
cp #Copy files/folders from.the containers filesystem to the host path 

#创建一个新的容器，同run，但不启动容器
create #Create a new container

#查看docker容器变化
diff #Inspect changes on a container's filesystem 

#从docker服务获取容器实时事件
events #Get real time events from the server

#在已存在的容器上运行命令
exec #Run a command in an existing container 

#导出容器的内容流作为一个tar归档文件[对应import]
export #Stream the contents of a container as a tar archive 

#展示一个镜像形成历史
history #Show the history of an image

#列出系统当前镜像
images #List images

#从tar包中的内容创建一个新的文件系统映像[对应export]
import #Create a new filesystem image from the contents of a tarball

1.4、Docker镜像

1.4.1、是什么

1.4.1.1、什么是镜像

镜像
是一种轻量级、可执行的独立软件包，它包含运行某个软件所需的所有内容，我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)，这个打包好的运行环境就是image镜像文件。
只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。

1.4.1.2、分层的镜像

以我们的pu为例，在下载的过程中我们可以看到docker的镜像好像是在一层一层的在下载>

1.4.1.3、UnionFS联合文件系统####

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

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

1.4.1.4、Docker镜像加载原理

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

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

平时我们安装进虚拟机的CentOS都是好几个G，为什么docker这里才200M? ?
对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别,因此不同的发行版可以公用
bootfs。

1.4.1.5、为什么Docker镜像采用这种分层结构呢？

镜像分层最大的一个好处就是共享资源，方便复制迁移，就是为了复用。

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

1.4.2、重点理解

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

当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。
所有对容器的改动。无论添加、删除、还是修改文件都只会发生在容器层中。只有容器层是可写的，容器层下面的所有镜像层都是只读的。

1.4.3、Docker镜像commit操作案列