文章目录
- docker教案
-
- [第1章 容器生态系统](#第1章 容器生态系统)
-
- [001 了解容器技术](#001 了解容器技术)
- [002 容器生态系统](#002 容器生态系统)
- [003 容器生态系统(续)](#003 容器生态系统(续))
- [004 安装docker](#004 安装docker)
- [005 docker C/S分离部署](#005 docker C/S分离部署)
- [第2章 容器架构](#第2章 容器架构)
-
- [006 容器What,Why,How](#006 容器What,Why,How)
-
- [**What - 什么是容器？**](#What - 什么是容器？)
- [Why - 为什么需要容器？](#Why - 为什么需要容器？)
- [How - 容器是如何工作的？](#How - 容器是如何工作的？)
- Docker介绍
- [007 Docker架构详解](#007 Docker架构详解)
- [008 Docker组件如何协作？](#008 Docker组件如何协作？)
- [第3章 镜像](#第3章 镜像)
-
- [009 最小的镜像](#009 最小的镜像)
- [010 base镜像](#010 base镜像)
- [011 镜像的分层结构](#011 镜像的分层结构)
- [012 构建镜像](#012 构建镜像)
- [013 Dockerfile构建镜像](#013 Dockerfile构建镜像)
- [014 镜像的缓存特性](#014 镜像的缓存特性)
- [015 调试Dockerfile](#015 调试Dockerfile)
- [016 Dockerfile常用指令](#016 Dockerfile常用指令)
- [017 RUN vs CMD vs ENTRYPOINT](#017 RUN vs CMD vs ENTRYPOINT)
- [018 镜像命名的最佳实践](#018 镜像命名的最佳实践)
- [019 使用公共Registry-dockerhub](#019 使用公共Registry-dockerhub)
- [020 搭建本地Registry](#020 搭建本地Registry)
- [021 Docker镜像小结](#021 Docker镜像小结)
- [第4章 容器](#第4章 容器)
-
- [022 如何运行容器？](#022 如何运行容器？)
- [023 两种进入容器的方法](#023 两种进入容器的方法)
- [024 运行容器的最佳实践](#024 运行容器的最佳实践)
- [025 容器常用操作](#025 容器常用操作)
- [026 一张图搞懂容器所有操作](#026 一张图搞懂容器所有操作)
- [027 限制容器对内存的使用](#027 限制容器对内存的使用)
- [028 限制容器对CPU的使用](#028 限制容器对CPU的使用)
- [029 export和import容器](#029 export和import容器)
- [030 实现容器的底层技术](#030 实现容器的底层技术)
-
-
- [**UTS namespace**](#UTS namespace)
- [**IPC namespace**](#IPC namespace)
- [**PID namespace**](#PID namespace)
- [**Network namespace**](#Network namespace)
- [**User namespace**](#User namespace)
-
- [第5章 网络](#第5章 网络)
-
- [031 none和host网络的适用场景](#031 none和host网络的适用场景)
-
- [**none 网络**](#none 网络)
- [**host 网络**](#host 网络)
- [032 学容器必须懂brige网络](#032 学容器必须懂brige网络)
- [033 如何自定义容器网络？](#033 如何自定义容器网络？)
- [034 理解容器之间的连通性](#034 理解容器之间的连通性)
- [035 容器通信的三种方式](#035 容器通信的三种方式)
-
- [**IP 通信**](#IP 通信)
- [**Docker DNS Server**](#Docker DNS Server)
- [**joined 容器**](#joined 容器)
- [036 容器如何访问外部世界](#036 容器如何访问外部世界)
- [037 外部世界如何访问容器](#037 外部世界如何访问容器)
- 实战：安装tomcat
- **本章小结**
- [第6章 存储](#第6章 存储)
-
- [038 Docker的两类存储资源](#038 Docker的两类存储资源)
- [039 Data Volume之bind mount](#039 Data Volume之bind mount)
- [040 Data Volume之docker managed volume](#040 Data Volume之docker managed volume)
- [041 如何共享数据](#041 如何共享数据)
-
- [**容器与 host 共享数据**](#容器与 host 共享数据)
- **容器之间共享数据**
- [042 用volume container共享数据](#042 用volume container共享数据)
- [043 data-packed volume container](#043 data-packed volume container)
- [044 volume生命周期管理](#044 volume生命周期管理)
- 实战：安装mysql
- [第7章 容器监控](#第7章 容器监控)
- [第8章 容器日志](#第8章 容器日志)
-
- [Docker logs](#Docker logs)
- [第9章 Docker-compose](#第9章 Docker-compose)
-
- 命令说明
- [Compose 模板](#Compose 模板)
- 模板文件结构
- Compose文档
- 实战-Wordpress
- [第10章 docker图形界面管理](#第10章 docker图形界面管理)
-
- [DockerUI 容器管理器的安装与使用](#DockerUI 容器管理器的安装与使用)
- [Docker 图形化界面管理工具 Portainer](#Docker 图形化界面管理工具 Portainer)
- 综合实验
docker教案
第1章 容器生态系统
001 了解容器技术
- 系统讲解当前最流行的容器技术。
从容器的整个生态环境到各个具体的技术，从整体到细节逐一讨论。 - 重实践并兼顾理论。
从实际操作的角度带领大家学习容器技术。
为什么要写这个？
简单回答是：容器技术非常热门，但门槛高。
容器技术是继大数据和云计算之后又一炙手可热的技术，而且未来相当一段时间内都会非常流行。
对 IT 行业来说，这是一项非常有价值的技术。而对 IT 从业者来说，掌握容器技术是市场的需要，也是提升自我价值的重要途径。
现在以 Docker 为代表的容器技术来了，而且关注度越来越高，这一点可以从 google 趋势 中 Docker 的搜索上升趋势（蓝色曲线）中清楚看到。
002 容器生态系统
对于像容器这类平台级别的技术，通常涉及的知识范围会很广，相关的软件，解决方案也会很多，初学者往往容易迷失。
那怎么办呢？
我们可以从生活经验中寻找答案。
当我们去陌生城市旅游想了解一下这个城市一般我们会怎么做？
我想大部分人应该会打开手机看一下这个城市的地图：
- 城市大概的位置和地理形状是什么？
- 都由哪几个区或县组成？
- 主要的交通干道是哪几条？
同样的道理，学习容器技术我们可以先从天上鸟瞰一下：
- 容器生态系统包含哪些不同层次的技术？
- 不同技术之间是什么关系？
- 哪些是核心技术哪些是辅助技术？
首先得对容器技术有个整体认识，之后我们的学习才能够有的放矢，才能够分清轻重缓急，做到心中有数，这样就不容易迷失了。
接下来我会根据自己的经验帮大家规划一条学习路线，一起探索容器生态系统。
学习新技术得到及时反馈是非常重要的，所以我们马上会搭建实验环境，并运行第一个容器，感受什么是容器。
千里之行始于足下，让我们从了解生态系统开始吧。
鸟瞰容器生态系统
一谈到容器，大家都会想到 Docker。
Docker 现在几乎是容器的代名词。确实，是 Docker 将容器技术发扬光大。同时，大家也需要知道围绕 Docker 还有一个生态系统。Docker 是这个生态系统的基石，但完善的生态系统才是保障 Docker 以及容器技术能够真正健康发展的决定因素。
大致来看，容器生态系统包含核心技术、平台技术和支持技术。
下面分别介绍。
容器核心技术
容器核心技术是指能够让 container 在 host os上运行起来的那些技术。
这些技术包括容器规范、容器 runtime、容器管理工具、容器定义工具、Registry 以及 容器 OS，下面分别介绍。
容器规范
容器不光是 Docker，还有其他容器，比如 CoreOS 的 rkt、红帽公司podman、containerd。为了保证容器生态的健康发展，保证不同容器之间能够兼容，包含 Docker、CoreOS、Google在内的若干公司共同成立了一个叫 Open Container Initiative（OCI） 的组织，其目是制定开放的容器规范。
目前 OCI 发布了两个规范：runtime spec 和 image format spec。
有了这两个规范，不同组织和厂商开发的容器能够在不同的 runtime 上运行。这样就保证了容器的可移植性和互操作性。
容器 runtime
runtime 是容器真正运行的地方。runtime 需要跟操作系统 kernel 紧密协作，为容器提供运行环境。
如果大家用过 Java，可以这样来理解 runtime 与容器的关系：
Java 程序就好比是容器，JVM 则好比是 runtime。JVM 为 Java 程序提供运行环境。同样的道理，容器只有在 runtime 中才能运行。
lxc、runc 和 rkt 是目前主流的三种容器 runtime。
lxc 是 Linux 上老牌的容器 runtime。Docker 最初也是用 lxc 作为 runtime。
runc 是 Docker 自己开发的容器 runtime，符合 oci 规范，也是现在 Docker 的默认 runtime。
rkt 是 CoreOS 开发的容器 runtime，符合 oci 规范，因而能够运行 Docker 的容器。
容器管理工具
光有 runtime 还不够，用户得有工具来管理容器啊。容器管理工具对内与 runtime 交互，对外为用户提供 interface，比如 CLI。这就好比除了 JVM，还得提供 java 命令让用户能够启停应用不是。
lxd 是 lxc 对应的管理工具。
runc 的管理工具是 docker engine。docker engine 包含后台 deamon 和 cli 两个部分。我们通常提到 Docker，一般就是指的 docker engine。
rkt 的管理工具是 rkt cli。
容器定义工具
容器定义工具允许用户定义容器的内容和属性，这样容器就能够被保存，共享和重建。
docker image 是 docker 容器的模板，runtime 依据 docker image 创建容器。
dockerfile 是包含若干命令的文本文件，可以通过这些命令创建出 docker image。
ACI (App Container Image) 与 docker image 类似，只不过它是由 CoreOS 开发的 rkt 容器的 image 格式。
Registry
容器是通过 image 创建的，需要有一个仓库来统一存放 image，这个仓库就叫做 Registry。
企业可以用 Docker Registry 构建私有的 Registry。
Docker Hub（https://hub.docker.com） 是 Docker 为公众提供的托管 Registry，上面有很多现成的 image，为 Docker 用户提供了极大的便利。
Quay.io（https://quay.io/）是另一个公共托管 Registry，提供与 Docker Hub 类似的服务。
容器 OS
由于有容器 runtime，几乎所有的 Linux、MAC OS 和 Windows 都可以运行容器。但这不并没有妨碍容器 OS 的问世。
KVM （Kernel-based virtual machine）只能在Linux上运行，全称：基于内核的虚拟化机器，这里的内核指的就是Linux的内核
容器 OS 是专门运行容器的操作系统。与常规 OS 相比，容器 OS 通常体积更小，启动更快。因为是为容器定制的 OS，通常它们运行容器的效率会更高。
目前已经存在不少容器 OS，CoreOS、atomic 和 ubuntu core 是其中的杰出代表。
下一节继续介绍容器平台技术和容器支持技术。
003 容器生态系统(续)
容器生态系统包含核心技术、平台技术和支持技术三个方面。上一节我们讨论了核心技术，今天讨论另外两个部分。
容器平台技术
容器核心技术使得容器能够在单个 host 上运行。而容器平台技术能够让容器作为集群在分布式环境中运行。
容器平台技术包括容器编排引擎、容器管理平台和基于容器的 PaaS。
容器编排引擎
基于容器的应用一般会采用微服务架构。在这种架构下，应用被划分为不同的组件，并以服务的形式运行在各自的容器中，通过 API 对外提供服务。为了保证应用的高可用，每个组件都可能会运行多个相同的容器。这些容器会组成集群，集群中的容器会根据业务需要被动态地创建、迁移和销毁。
大家可以看到，这样一个基于微服务架构的应用系统实际上是一个动态的可伸缩的系统。这对我们的部署环境提出了新的要求，我们需要有一种高效的方法来管理容器集群。而这，就是容器编排引擎要干的工作。
所谓编排（orchestration），通常包括容器管理、调度、集群定义和服务发现等。通过容器编排引擎，容器被有机的组合成微服务应用，实现业务需求。
docker swarm 是 Docker 开发的容器编排引擎。
kubernetes 是 Google 领导开发的开源容器编排引擎，同时支持 Docker 和 CoreOS 容器。
mesos 是一个通用的集群资源调度平台，mesos 与 marathon 一起提供容器编排引擎功能。
以上三者是当前主流的容器编排引擎。
容器管理平台
容器管理平台是架构在容器编排引擎之上的一个更为通用的平台。通常容器管理平台能够支持多种编排引擎，抽象了编排引擎的底层实现细节，为用户提供更方便的功能，比如 application catalog 和一键应用部署等。
Rancher 和 ContainerShip 是容器管理平台的典型代表。
基于容器的 PaaS
基于容器的 PaaS 为微服务应用开发人员和公司提供了开发、部署和管理应用的平台，使用户不必关心底层基础设施而专注于应用的开发。
Deis、Flynn 和 Dokku 都是开源容器 PaaS 的代表。
容器支持技术
下面这些技术被用于支持基于容器的基础设施。
容器网络
容器的出现使网络拓扑变得更加动态和复杂。用户需要专门的解决方案来管理容器与容器，容器与其他实体之间的连通性和隔离性。
docker network 是 Docker 原生的网络解决方案。除此之外，我们还可以采用第三方开源解决方案，例如 flannel、weave 和 calico。不同的方案设计和实现方式不同，各有优势和特定，我们可以根据实际需要来选型。
服务发现
动态变化是微服务应用的一大特点。当负载增加时，集群会自动创建新的容器；负载减小，多余的容器会被销毁。容器也会根据 host 的资源使用情况在不同 host 中迁移，容器的 IP 和端口也会随之发生变化。
在这种动态的环境下，必须要有一种机制让 client 能够知道如何访问容器提供的服务。这就是服务发现技术要完成的工作。
服务发现会保存容器集群中所有微服务最新的信息，比如 IP 和端口，并对外提供 API，提供服务查询功能。
etcd、consul 和 zookeeper 是服务发现的典型解决方案。
监控
监控对于基础架构非常重要，而容器的动态特征对监控提出更多挑战。
针对容器环境，已经涌现出很多监控工具和方案。
docker ps/top/stats 是 Docker 原生的命令行监控工具。除了命令行，Docker 也提供了 stats API，用户可以通过 HTTP 请求获取容器的状态信息。
sysdig、cAdvisor/Heapster 和 Weave Scope 是其他开源的容器监控方案。
数据管理
容器经常会在不同的 host 之间迁移，如何保证持久化数据也能够动态迁移，是 Flocker 这类数据管理工具提供的能力。
日志管理
日志为问题排查和事件管理提供了重要依据。
docker logs 是 Docker 原生的日志工具。而 logspout 对日志提供了路由功能，它可以收集不同容器的日志并转发给其他工具进行后处理。
安全性
对于年轻的容器，安全性一直是业界争论的焦点。
OpenSCAP 能够对容器镜像进行扫描，发现潜在的漏洞。
004 安装docker
直接操作的环境：https://labs.play-with-docker.com/
环境选择
容器需要管理工具、runtime 和操作系统，我们的选择如下：
- 管理工具 - Docker Engine，Docker 最流行使用最广泛。
- runtime - runc，Docker 的默认 runtime
- 操作系统 - CentOS Stream8
安装操作系统
基于CentOS-Stream-8模板制作.pdf这个实验手册做出来的模板克隆一个虚拟机命名为docker，并配置静态IP 192.168.108.30，主机名改为docker
bash
[root@localhost ~]# hostnamectl set-hostname docker
[root@localhost ~]# nmcli connection modify ens160 ipv4.method manual ipv4.addresses 192.168.108.30/24 ipv4.gateway 192.168.108.2 ipv4.dns 192.168.108.2 autoconnect yes
[root@localhost ~]# nmcli connection up ens160安装 Docker
Docker 支持几乎所有的 Linux 发行版，也支持 Mac 和 Windows。各操作系统的安装方法可以访问：https://docs.docker.com/engine/installation/ 或者https://mirrors.aliyun.com 或者https://mirrors.huaweicloud.com
卸载旧版本（可选）
bash
[root@docker ~]# yum remove docker-ce安装必要工具
bash
# devicemapper 存储驱动已经在 docker 18.09 版本中被废弃，所以在后续的安Docker装中无需安装devicemapper支持。
[root@localhost ~]# yum install -y yum-utils device-mapper-persistent-data lvm2 vim
#配置仓库
[root@localhost ~]# yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
Adding repo from: https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
#建立缓存
[root@localhost ~]# yum makecache
Docker CE Stable - x86_64 57 kB/s | 66 kB 00:01
CentOS Stream 8 - BaseOS 8.3 kB/s | 3.9 kB 00:00
CentOS Stream 8 - AppStream 9.8 kB/s | 4.4 kB 00:00
Metadata cache created.allinone部署
安装软件
bash
[root@docker ~]# yum install -y docker-ce配置服务
bash
[root@docker ~]# systemctl enable docker.service --now验证安装
查看docker版本
bash
[root@docker ~]# docker --version
Docker version 26.1.3, build b72abbb验证docker状态
bash
[root@docker ~]# systemctl status docker
● docker.service - Docker Application Container Engine
Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; vendor preset: disabled)
Active: active (running) since Wed 2025-09-03 13:51:07 CST; 36s ago
Docs: https://docs.docker.com
Main PID: 1813 (dockerd)
Tasks: 10
Memory: 135.7M
CGroup: /system.slice/docker.service
└─1813 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock配置镜像加速器(阿里云)
只对自己的产品提供加速器
阿里云官网：阿里云-计算，为了无法计算的价值
参考操作文档，操作
bash
[root@docker ~]# sudo mkdir -p /etc/docker
[root@docker ~]# sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://spcqvmfn.mirror.aliyuncs.com"]
}
EOF
[root@docker ~]# sudo systemctl daemon-reload
[root@docker ~]# sudo systemctl restart docker
#检查镜像加速器配置
[root@docker ~]# docker info
Client: Docker Engine - Community
Version: 26.1.3
Context: default
Debug Mode: false
Plugins:
buildx: Docker Buildx (Docker Inc.)
Version: v0.14.0
Path: /usr/libexec/docker/cli-plugins/docker-buildx
compose: Docker Compose (Docker Inc.)
Version: v2.27.0
Path: /usr/libexec/docker/cli-plugins/docker-compose
Server:
Containers: 0
Running: 0
Paused: 0
Stopped: 0
Images: 0
Server Version: 26.1.3
Storage Driver: overlay2
Backing Filesystem: xfs
Supports d_type: true
Using metacopy: false
Native Overlay Diff: true
userxattr: false
Logging Driver: json-file
Cgroup Driver: cgroupfs
Cgroup Version: 1
Plugins:
Volume: local
Network: bridge host ipvlan macvlan null overlay
Log: awslogs fluentd gcplogs gelf journald json-file local splunk syslog
Swarm: inactive
Runtimes: io.containerd.runc.v2 runc
Default Runtime: runc
Init Binary: docker-init
containerd version: 8b3b7ca2e5ce38e8f31a34f35b2b68ceb8470d89
runc version: v1.1.12-0-g51d5e94
init version: de40ad0
Security Options:
seccomp
Profile: builtin
Kernel Version: 4.18.0-553.6.1.el8.x86_64
Operating System: CentOS Stream 8
OSType: linux
Architecture: x86_64
CPUs: 4
Total Memory: 7.486GiB
Name: docker
ID: 96160847-9a97-40f4-997c-d12efaaef738
Docker Root Dir: /var/lib/docker
Debug Mode: false
Experimental: false
Insecure Registries:
127.0.0.0/8
Registry Mirrors:
`https://spcqvmfn.mirror.aliyuncs.com/ <---看这
Live Restore Enabled: false配置镜像加速器(华为云)
看镜像加速器如何使用
bash
[root@docker ~]# vi /etc/docker/daemon.json
{
"registry-mirrors": [ "https://054b8ac70e8010d90f2ac00ef29e6580.mirror.swr.myhuaweicloud.com" ]
}
# 按"Esc"，输入:wq保存并退出。
#重启容器引擎
[root@docker ~]# systemctl restart docker
#确认配置结果
[root@docker ~]# docker info
Client: Docker Engine - Community
Version: 26.1.3
Context: default
Debug Mode: false
Plugins:
buildx: Docker Buildx (Docker Inc.)
Version: v0.14.0
Path: /usr/libexec/docker/cli-plugins/docker-buildx
compose: Docker Compose (Docker Inc.)
Version: v2.27.0
Path: /usr/libexec/docker/cli-plugins/docker-compose
Server:
Containers: 0
Running: 0
Paused: 0
Stopped: 0
Images: 0
Server Version: 26.1.3
Storage Driver: overlay2
Backing Filesystem: xfs
Supports d_type: true
Using metacopy: false
Native Overlay Diff: true
userxattr: false
Logging Driver: json-file
Cgroup Driver: cgroupfs
Cgroup Version: 1
Plugins:
Volume: local
Network: bridge host ipvlan macvlan null overlay
Log: awslogs fluentd gcplogs gelf journald json-file local splunk syslog
Swarm: inactive
Runtimes: io.containerd.runc.v2 runc
Default Runtime: runc
Init Binary: docker-init
containerd version: 8b3b7ca2e5ce38e8f31a34f35b2b68ceb8470d89
runc version: v1.1.12-0-g51d5e94
init version: de40ad0
Security Options:
seccomp
Profile: builtin
Kernel Version: 4.18.0-553.6.1.el8.x86_64
Operating System: CentOS Stream 8
OSType: linux
Architecture: x86_64
CPUs: 4
Total Memory: 7.486GiB
Name: docker
ID: 96160847-9a97-40f4-997c-d12efaaef738
Docker Root Dir: /var/lib/docker
Debug Mode: false
Experimental: false
Insecure Registries:
127.0.0.0/8
Registry Mirrors:
`https://054b8ac70e8010d90f2ac00ef29e6580.mirror.swr.myhuaweicloud.com/ <---看这
Live Restore Enabled: false配置加速器是因为，私人不允许访问docker的仓库，所以华为将docker仓库的镜像提供给我们华为的途径，这样下载镜像就直接使用华为的即可
运行第一个容器
环境就绪，马上运行第一个容器，执行命令：
bash
[root@docker ~]# docker run hello-world
其过程可以简单的描述为：
- 从本地查找hello-wrold镜像，没找到
- 从 Docker Hub 下载hello-world镜像。
- 启动hello-world容器。
清空刚才的实验环境：
bash
[root@docker ~]# docker rm -f $(docker ps -aq) #删除所有容器
[root@docker ~]# docker rmi -f hello-world #删除镜像hello-world此刻docker环境没有问题了，关机拍摄快照
运行第二个容器
bash
[root@docker ~]# docker run -d -p 80:80 httpd
Unable to find image 'httpd:latest' locally
latest: Pulling from library/httpd
852e50cd189d: Pull complete
67d51c33d390: Pull complete
b0ad2a3b9567: Pull complete
136f1f71f30c: Pull complete
01f8ace29294: Pull complete
Digest: sha256:fddc534b7f6bb6197855be559244adb11907d569aae1283db8e6ce8bb8f6f456
Status: Downloaded newer image for httpd:latest
817f24cca3514568f9b7a7cac6f183734077fb74caf4c62502acd2a4d0d29520其过程可以简单的描述为：
- 从 Docker Hub 下载 httpd 镜像。镜像中已经安装好了 Apache HTTP Server。
- 启动 httpd 容器，并将容器的 80 端口映射到 host 的 80 端口。
下面我们可以通过浏览器验证容器是否正常工作。在浏览器中输入 http://[your host os IP]
bash
[root@docker ~]# curl 192.168.108.30
<html><body><h1>It works!</h1></body></html>
可以访问容器的 http 服务了，第一个容器运行成功！我们轻轻松松就拥有了一个 WEB 服务器。
005 docker C/S分离部署
基于CentOS-Stream-8模板制作.pdf这个实验手册做出来的模板克隆两个虚拟机命名为docker_client和docker_server
docker server端配置
配置ip 192.168.108.30
配置hostname docker_server
bash
root@localhost ~]# hostnamectl set-hostname docker_server
[root@localhost ~]# nmcli connection modify ens160 ipv4.method manual ipv4.addresses 192.168.108.30/24 ipv4.gateway 192.168.108.2 ipv4.dns 192.168.108.2 autoconnect yes
[root@localhost ~]# nmcli con up ens160安装软件
bash
[root@docker_server ~]# yum install -y yum-utils device-mapper-persistent-data lvm2 vim
[root@localhost ~]# yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
Adding repo from: https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
[root@docker_server ~]# yum makecache
[root@docker_server ~]# yum install -y docker-ce
[root@docker_server ~]# systemctl enable docker.service --now
[root@docker_server ~]# vi /etc/docker/daemon.json
{
"registry-mirrors": [ "https://054b8ac70e8010d90f2ac00ef29e6580.mirror.swr.myhuaweicloud.com" ]
}
# 按"Esc"，输入:wq保存并退出。
#重启容器引擎
[root@docker_server ~]# systemctl restart docker配置服务
bash
[root@docker_server ~]# vim /usr/lib/systemd/system/docker.service
# 在ExecStart参数中最后添加 -H tcp://0.0.0.0:2375 docker默认监听2375
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock -H tcp://0.0.0.0:2375
[root@docker_server ~]# systemctl daemon-reload
[root@docker_server ~]# systemctl restart docker.service
[root@docker_server ~]# systemctl stop firewalld配置效果如下
验证
bash
[root@docker_server ~]# yum install lsof
[root@docker_server ~]# lsof -i :2375
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
dockerd 5440 root 3u IPv6 44991 0t0 TCP *:docker (LISTEN)docker_client端
配置ip 192.168.108.31
bash
[root@localhost ~]# hostnamectl set-hostname docker_client
[root@localhost ~]# nmcli connection modify ens160 ipv4.method manual ipv4.addresses 192.168.108.31/24 ipv4.gateway 192.168.108.2 ipv4.dns 192.168.108.2 autoconnect yes
[root@localhost ~]# nmcli con up ens160只安装docker客户端
bash
[root@docker-client ~]# yum install -y yum-utils device-mapper-persistent-data lvm2 vim
[root@docker-client ~]# yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
Adding repo from: https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
[root@docker-client ~]# yum makecache
[root@docker-client ~]# yum install -y docker-ce-cli验证
bash
[root@docker_client ~]# docker run hello-world #client直接执行报错，没有装服务端
docker: Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?.
See 'docker run --help'.
# client端连接server端执行命令
[root@docker-client ~]# docker -H 192.168.108.30 run hello-world
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/
For more examples and ideas, visit:
https://docs.docker.com/get-started/
[root@docker-client ~]# docker -H 192.168.108.30 images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest d2c94e258dcb 17 months ago 13.3kB
#这里也可以切换到Server端查看现象说明：client只做管理，image和container存储在server端。
第2章 容器架构
006 容器What,Why,How
学习任何东西都可以按照3W的框架进行，容器技术也是一样，先回答 What、Why 和 How 这三个问题。
容器发展史
- 1979年，在Unix V7 的开发过程中，引入Chroot Jail以及Chroot系统调用Chroot jail被用于"Change Root"，它被认为是最早的容器化技术之一。它允许您将进程及其子进程与操作系统的其余部分隔离开来。这种隔离的唯一问题是根进程（root process）可以轻松地退出chroot。它从未考虑实现安全机制。
- 1982年，Chroot加入BSD。
- 2000年，在FreeBSD OS中引入FreeBSD Jail，旨在为简单的Chroot文件隔离带来更多安全性。FreeBSD Jail允许管理员将FreeBSD OS划分为几个独立的小型系统 - 称为"jails"，还可以为每个小型系统分配IP地址。
- 2001年，Linux内核具有操作系统级的虚拟化的功能以后推出了Linux VServer。它使用了类似chroot的机制与"安全上下文"（"security context"）以及操作系统虚拟化（容器化）相结合来提供虚拟化解决方案，允许您在单个Linux发行版上运行多个Linux发行版。
- 2004年，Solaris Containers问世，它使用系统资源控制和"区域"（zone）实现边界分离。
- 2006年，Google推出Process Containers，旨在限制，计算和隔离一组进程的资源使用（CPU，内存，磁盘I/O，网络）。2007年，命名为控制组-cgroups，最终合并到Linux内核2.6.24。
- 2008年，LXC（LinuX Containers）是第一个Linux容器管理器，使用cgroups和命名空间(namespace)在单个Linux内核上运行多个容器。
- 2013年，Docker推出了的第一个版本。在LXC的基础上，Docker进一步优化了容器的使用体验。后来用自己的库libcontainer替换了该容器管理器。
- 2014年，Google推出容器LMCTFY（Let me contain that for you），谷歌容器栈的开源版本，提供Linux应用程序容器。谷歌工程师一直在与Docker合作libcontainer，并将核心概念和抽象移植到libcontainer。因此没有积极开发LMCTFY项目，未来LMCTFY项目的核心可能会被libcontainer取代。谷歌是容器化行业的领导者。谷歌的一切都在容器上运行。每周有超过20亿个容器在Google基础架构上运行。
- 2014年12月，CoreOS发布并开始支持rkt。
What - 什么是容器？
容器是一种轻量级、快启动、可移植、自包含的软件打包技术，使应用程序可以在几乎任何地方以相同的方式运行。开发人员在自己笔记本上创建并测试好的容器，无需任何修改就能够在生产系统的虚拟机、物理服务器或公有云主机上运行。
容器与虚拟机
谈到容器，就不得不将它与虚拟机进行对比，因为两者都是为应用提供封装和隔离。
容器由两部分组成：
- 应用程序本身
- 依赖：比如应用程序需要的库或其他软件
容器在 Host 操作系统的用户空间中运行，与操作系统的其他进程隔离。这一点显著区别于的虚拟机。
传统的虚拟化技术，比如 VMWare, KVM, Xen，目标是创建完整的虚拟机。为了运行应用，除了部署应用本身及其依赖（通常几十 MB），还得安装整个操作系统（几十 GB）。
下图展示了二者的区别。
| 容器 | 虚拟机 | |
|---|---|---|
| 启动速度 | 秒甚至毫秒启动 | 数秒至数十秒 |
| 系统内核 | 共享内核 | 不共享内核 |
| 实现技术 | 利用Linux内核技术Namespace/Cgroup等实现。 | 依赖虚拟化技术实现，由Hypervisor层实现对资源的隔离 |
| 隔离效果 | 进程级别的隔离 | 系统资源级别的隔离 |
| 资源消耗（性能） | 容器中的应用只是宿主机上的一个普通进程 | 使用虚拟化技术，就会有额外的资源消耗和占用 |
| 资源调用 （敏捷性） | 应用进程直接由宿主机OS管理 | 应用进程需经过Hypervisor的拦截和处理，才能调用系统资源 |
| 运行数量 | 一台服务器上能启动1000+容器 | 一台服务器上一般不超过100台虚拟机 |
| 应用 | DevOps、微服务等 | 用于硬件资源划分 |
| 镜像 | 分层镜像 | 非分层镜像 |
如图所示，由于所有的容器共享同一个 Host OS，这使得容器在体积上要比虚拟机小很多。另外，启动容器不需要启动整个操作系统，所以容器部署和启动速度更快，开销更小，也更容易迁移。
Why - 为什么需要容器？
为什么需要容器？容器到底解决的是什么问题？
简要的答案是：容器使软件具备了超强的可移植能力。
容器解决的问题
我们来看看今天的软件开发面临着怎样的挑战？
如今的系统在架构上较十年前已经变得非常复杂了。以前几乎所有的应用都采用三层架构（Presentation/Application/Data），系统部署到有限的几台物理服务器上（Web Server/Application Server/Database Server）。
而今天，开发人员通常使用多种服务（比如 MQ，Cache，DB）构建和组装应用，而且应用很可能会部署到不同的环境，比如虚拟服务器，私有云和公有云。
一方面应用包含多种服务，这些服务有自己所依赖的库和软件包；另一方面存在多种部署环境，服务在运行时可能需要动态迁移到不同的环境中。这就产生了一个问题：
如何让每种服务能够在所有的部署环境中顺利运行？
于是我们得到了下面这个矩阵：
各种服务和环境通过排列组合产生了一个大矩阵。开发人员在编写代码时需要考虑不同的运行环境，运维人员则需要为不同的服务和平台配置环境。对他们双方来说，这都是一项困难而艰巨的任务。
如何解决这个问题呢？
聪明的技术人员从传统的运输行业找到了答案。
几十年前，运输业面临着类似的问题。
每一次运输，货主与承运方都会担心因货物类型的不同而导致损失，比如几个铁桶错误地压在了一堆香蕉上。另一方面，运输过程中需要使用不同的交通工具也让整个过程痛苦不堪：货物先装上车运到码头，卸货，然后装上船，到岸后又卸下船，再装上火车，到达目的地，最后卸货。一半以上的时间花费在装、卸货上，而且搬上搬下还容易损坏货物。
这同样也是一个 NxM 的矩阵。
幸运的是，集装箱的发明解决这个难题。
任何货物，无论钢琴还是保时捷，都被放到各自的集装箱中。集装箱在整个运输过程中都是密封的，只有到达最终目的地才被打开。标准集装箱可以被高效地装卸、重叠和长途运输。现代化的起重机可以自动在卡车、轮船和火车之间移动集装箱。集装箱被誉为运输业与世界贸易最重要的发明。
Docker 将集装箱思想运用到软件打包上，为代码提供了一个基于容器的标准化运输系统。Docker 可以将任何应用及其依赖打包成一个轻量级、可移植、自包含的容器。容器可以运行在几乎所有的操作系统上。
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
其实，"集装箱" 和 "容器" 对应的英文单词都是 "Container"。"容器" 是国内约定俗成的叫法，可能是因为容器比集装箱更抽象，更适合软件领域的原故吧。
我个人认为：在老外的思维中，"Container" 只用到了集装箱这一个意思，Docker 的 Logo 不就是一堆集装箱吗？
Docker 的特性
我们可以看看集装箱思想是如何与 Docker 各种特性相对应的。
| 特性 | 集装箱 | Docker |
|---|---|---|
| 打包对象 | 几乎任何货物 | 任何软件及其依赖 |
| 硬件依赖 | 标准形状和接口允许集装箱被装卸到各种交通工具，整个运输过程无需打开 | 容器无需修改便可运行在几乎所有的平台上 -- 虚拟机、物理机、公有云、私有云 |
| 隔离性 | 集装箱可以重叠起来一起运输，香蕉再也不会被铁桶压烂了 | 资源、网络、库都是隔离的，不会出现依赖问题 |
| 自动化 | 标准接口使集装箱很容易自动装卸和移动 | 提供 run, start, stop 等标准化操作，非常适合自动化 |
| 高效性 | 无需开箱，可在各种交通工具间快速搬运 | 轻量级，能够快速启动和迁移 |
| 职责分工 | 货主只需考虑把什么放到集装箱里；承运方只需关心怎样运输集装箱 | 开发人员只需考虑怎么写代码；运维人员只需关心如何配置基础环境 |
容器的优势
对于开发人员 - Build Once, Run Anywhere
容器意味着环境隔离和可重复性。开发人员只需为应用创建一次运行环境，然后打包成容器便可在其他机器上运行。另外，容器环境与所在的 Host 环境是隔离的，就像虚拟机一样，但更快更简单。
对于运维人员 - Configure Once, Run Anything
只需要配置好标准的 runtime 环境，服务器就可以运行任何容器。这使得运维人员的工作变得更高效，一致和可重复。容器消除了开发、测试、生产环境的不一致性。
How - 容器是如何工作的？
从下节开始我们将学习容器核心知识的最主要部分。首先会介绍 Docker 的架构，然后分章节详细讨论 Docker 的镜像、容器、网络和存储。
容器与虚拟机比较
谈到容器，就不得不将它与虚拟机进行对比，因为两者都是为应用提供封装和隔离。
容器由两部分组成：
- 应用程序本身
- 依赖：比如应用程序需要的库或其他软件
容器在 Host 操作系统的用户空间中运行，与操作系统的其他进程隔离。这一点显著区别于的虚拟机。
传统的虚拟化技术，比如 VMWare, KVM, Xen，目标是创建完整的虚拟机。为了运行应用，除了部署应用本身及其依赖（通常几十 MB），还得安装整个操作系统（几十 GB）。
下图展示了二者的区别：
如图所示：
- 所有的容器共享同一个 Host OS，这使得容器在体积上要比虚拟机小很多。
- 另启动容器不需要启动整个操作系统，容器部署和启动速度更快，开销更小，也更容易迁移。
容器可以在核心CPU本地运行指令，而不需要任何专门的解释机制。与虚拟化相比，这样既不需要指令级模拟，也不需要即时编译。
| 特性 | 容器 | 虚拟机 |
|---|---|---|
| 启动速度 | 秒级 | 分钟级 |
| 性能 | 接近原生 | 较弱 |
| 内存代价 | 很小 | 较多 |
| 硬盘使用 | 一般为MB | 一般为GB |
| 运行密度 | 单击支持上千个容器 | 一般几十个 |
| 隔离性 | 安全隔离 | 完全隔离 |
| 迁移性 | 优秀 | 一般 |
Docker介绍
Docker是基于Go语言实现的开源容器项目，诞生于2013年年初，最初发起者是dotCloud公司。Docker自开源后受到广泛的关注和讨论，逐渐形成了围绕Docker容器的生态体系。由于Docker在业界造成的影响力实在太大，dotCloud公司后来也直接改名为Docker Inc，并专注于 Docker相关技术和产品的开发。
Docker提供了各种容器管理工具 （如分发、版本、移植等），让用户无需关注底层的操作，可以更简单明了地管理和使用容器；其次，Docker引入分层文件系统构建和高效的镜像机制降低了迁移难度，极大地提升了用户体验。用户操作Docker容器就像操作应用自身一样简单。
简单地讲，可以将Docker容器理解为一种轻量级的沙盒（sandbox）。**每个容器内运行着一个应用，不同的容器相互隔离，容器之间也可以通过网络互相通信。**容器的创建和停止都十分快速，几乎跟创建和终止原生应用一致；另外，容器自身对系统资源的额外需求也十分有限，远远低于传统虚拟机。很多时候，甚至直接把容器当作应用本身也没有任何问题。
Docker版本
Docker CE在17.03版本之前叫Docker Engine，Docker Engine的版本号范围:0.1.0~1.13.1。
在2017年3月2日,docker团队宣布企业版Docker Enterprise Edition(EE)发布.为了一致,免费的Docker Engine改名为Docker Community Edition(CE),并且采用基于时间的版本号方案.就在这一天,Docker EE和Docker CE的17.03版本发布,这也是第一个采用新的版本号方案的版本。
Docker CE/EE每个季度发布一次季度版本,也就是说每年会发布4个季度版本,17.03,17.06,17.09,17.12就是2017年的4个季度版本的版本号,同时Docker CE每个月还会发布一个EDGE版本，比如17.04,17.05,17.07,17.08,17.10,17.11.
Docker CE季度版本自发布后会有4个月的维护期；Docker EE季度版本自发布后会有12个月的维护期.
在基于时间的发布方案中，版本号格式为:YY.MM.，YY.MM代表年月，patch代表补丁号，从0开始，在季度版本(如17.03)的维护期内，bug修复相关的更新会以patch递增的方式发布,比如17.03.0->17.03.1->17.03.2.
Docker核心概念
Docker的大部分操作都围绕着它的三大核心概念------镜像、容器和仓库而展开。
Docker镜像
Docker镜像类似于虚拟机镜像，可以将它理解为一个只读的模板。例如，一个镜像可以包含一个基本的操作系统环境，里面仅安装了Apache应用程序（或用户需要的其他软件）。可以把它称为一个Apache镜像。镜像是创建Docker容器的基础。通过版本管理和增量的文件系统，Docker提供了一套十分简单的机制创建和更新现有的镜像，用户甚至可以从网上下载一个已经做好的应用镜像，并直接使用。
Docker容器
Docker容器类似于一个轻量级的沙箱，Docker利用容器来运行和隔离应用。容器是从镜像创建的应用运行实例。可以将其启动、开始、停止、删除，而这些容器都是彼此相互隔离的、互不可见的。可以把容器看做是一个简易版的Linux系统环境（包括root用户权限、进程空间、用户空间和网络空间等）以及运行在其中的应用程序打包而成的盒子。
Docker仓库
Docker仓库类似于代码仓库，它是Docker集中存放镜像文件的场所。仓库注册服务器存放着很多类镜像，每类镜像包括多个镜像文件，通过不同的标签（tag）来进行区分。例如存放Ubuntu操作系统镜像的分类中可能包括1804、1604、14.04、12.04等不同版本的镜像。
根据所存储的镜像公开分享与否，Docker仓库可以分为:
- 公开仓库（Public）
- 私有仓库（Private）
目前，最大的公开仓库是官方提供的Docker Hub，其中存放了数量庞大的镜像供用户下载。国内不少云服务提供商（如时速云、阿里云等）也提供了仓库的本地源，可以提供稳定的国内访问。
当然，用户如果不希望公开分享自己的镜像文件，Docker也支持用户在本地网络内创建一个只能自己访问的私有仓库。当用户创建了自己的镜像之后就可以使用push命令将它上传到指定的公有或者私有仓库。这样用户下次在另外一台机器上使用该镜像时，只需要将其从仓库上pull下来就可以了。
007 Docker架构详解
完整的Docker由以下几部分构成:
- (1) **守护进程(Daemon)：**Docker守护进程(dockerd)侦听Docker API请求并管理Docker对象,，如图像、容器、网络和卷。守护进程还可以与其他守护进程通信来管理Docker服务。
- (2) REST API: 主要与Docker Daemon进行交互，比如Docker Cli或者直接调用REST API；
- (3) 客户端(Docker Client): 它是与Docker交互的主要方式通过命令行接口(CLI)客户端(docker命令)，客户机将命令通过REST API发送给并执行其命令；
- (4) Register Repository 镜像仓库: Docker注册表存储Docker镜像，可以采用Docker Hub是公共注册仓库，或者采用企业内部自建的Harbor私有仓库;
- (5) Image 镜像: 映像是一个只读模板，带有创建Docker容器的指令。映像通常基于另一个映像，还需要进行一些额外的定制，你可以通过Docker Hub公共镜像仓库进行拉取对应的系统或者应用镜像;
- (6) Container 容器: 容器是映像的可运行实例。您可以使用Docker API或CLI创建、启动、停止、移动或删除容器。您可以将一个容器连接到一个或多个网络，将存储附加到它，甚至根据它的当前状态创建一个新映像。
- (7) Services : Docker引擎支持集群模式服务允许您跨多个Docker守护进程()扩展管理容器，服务允许您定义所需的状态，例如在任何给定时间必须可用的服务副本的数量。默认情况下，服务在所有工作节点之间进行负载平衡。对于使用者来说Docker服务看起来是一个单独的应用程序；
Docker 的核心组件包括：
- Docker 客户端 - Client
- Docker 服务器 - Docker daemon
- Docker 镜像 - Image
- Registry
- Docker 容器 - Container
Docker 架构如下图所示：
Docker 采用的是 Client/Server 架构。客户端向服务器发送请求，服务器负责构建、运行和分发容器。客户端和服务器可以运行在同一个 Host 上，客户端也可以通过 socket 或 REST API 与远程的服务器通信。
Docker 内部具体实现:
- 用户是使用Docker Client与Docker Daemon建立通信，并发送请求给后者。
- Docker Daemon作为Docker架构中的主体部分，首先提供Docker Server的功能使其可以接受Docker Client的请求。
- Docker Engine执行Docker内部的一系列工作，每一项工作都是以一个Job的形式的存在。
- Job的运行过程中，当需要容器镜像时，则从DockerRegistry中下载镜像，并通过镜像管理驱动Graph driver将下载镜像以Graph的形式存储。
- 当需要为Docker创建网络环境时，通过网络管理驱动Networkdriver创建并配置Docker容器网络环境。
- 当需要限制Docker容器运行资源或执行用户指令等操作时，则通过Exec driver来完成。
- Libcontainer是一项独立的容器管理包，Networkdriver以及Execdriver都是通过Libcontainer来实现具体对容器进行的操作。
Docker 客户端
最常用的 Docker 客户端是 docker 命令。通过 docker 我们可以方便地在 Host 上构建和运行容器。
docker 支持很多操作（子命令），后面会逐步用到。
shell
[root@docker ~]# docker
Usage: docker [OPTIONS] COMMAND
A self-sufficient runtime for containers
Common Commands:
run Create and run a new container from an image
exec Execute a command in a running container
ps List containers
build Build an image from a Dockerfile
pull Download an image from a registry
push Upload an image to a registry
images List images
login Log in to a registry
logout Log out from a registry
search Search Docker Hub for images
version Show the Docker version information
info Display system-wide information
Management Commands:
builder Manage builds
buildx* Docker Buildx
compose* Docker Compose
container Manage containers
context Manage contexts
image Manage images
manifest Manage Docker image manifests and manifest lists
network Manage networks
plugin Manage plugins
system Manage Docker
trust Manage trust on Docker images
volume Manage volumes
Swarm Commands:
swarm Manage Swarm
Commands:
attach Attach local standard input, output, and error streams to a running container
commit Create a new image from a container's changes
cp Copy files/folders between a container and the local filesystem
create Create a new container
diff Inspect changes to files or directories on a container's filesystem
events Get real time events from the server
export Export a container's filesystem as a tar archive
history Show the history of an image
import Import the contents from a tarball to create a filesystem image
inspect Return low-level information on Docker objects
kill Kill one or more running containers
load Load an image from a tar archive or STDIN
logs Fetch the logs of a container
pause Pause all processes within one or more containers
port List port mappings or a specific mapping for the container
rename Rename a container
restart Restart one or more containers
rm Remove one or more containers
rmi Remove one or more images
save Save one or more images to a tar archive (streamed to STDOUT by default)
start Start one or more stopped containers
stats Display a live stream of container(s) resource usage statistics
stop Stop one or more running containers
tag Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
top Display the running processes of a container
unpause Unpause all processes within one or more containers
update Update configuration of one or more containers
wait Block until one or more containers stop, then print their exit codes
Global Options:
--config string Location of client config files (default "/root/.docker")
-c, --context string Name of the context to use to connect to the daemon (overrides
DOCKER_HOST env var and default context set with "docker context use")
-D, --debug Enable debug mode
-H, --host list Daemon socket to connect to
-l, --log-level string Set the logging level ("debug", "info", "warn", "error", "fatal")
(default "info")
--tls Use TLS; implied by --tlsverify
--tlscacert string Trust certs signed only by this CA (default "/root/.docker/ca.pem")
--tlscert string Path to TLS certificate file (default "/root/.docker/cert.pem")
--tlskey string Path to TLS key file (default "/root/.docker/key.pem")
--tlsverify Use TLS and verify the remote
-v, --version Print version information and quit
Run 'docker COMMAND --help' for more information on a command.
For more help on how to use Docker, head to https://docs.docker.com/go/guides/除了 docker 命令行工具，用户也可以通过 REST API 与服务器通信。
Docker 服务器
Docker daemon 是服务器组件，以 Linux 后台服务的方式运行。
shell
[root@docker ~]# systemctl status docker.service
● docker.service - Docker Application Container Engine
Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; vendor preset: disabled)
Active: active (running) since Mon 2024-09-09 21:40:20 CST; 24h ago
Docs: https://docs.docker.com
Main PID: 2309 (dockerd)
Tasks: 10
Memory: 136.0M
CGroup: /system.slice/docker.service
└─2309 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
Sep 09 21:40:16 docker systemd[1]: Starting Docker Application Container Engine...
Sep 09 21:40:17 docker dockerd[2309]: time="2024-09-09T21:40:17.800157335+08:00" level=info msg="Star>
Sep 09 21:40:18 docker dockerd[2309]: time="2024-09-09T21:40:18.196566715+08:00" level=info msg="[gra>
Sep 09 21:40:18 docker dockerd[2309]: time="2024-09-09T21:40:18.208666863+08:00" level=info msg="Load>
Sep 09 21:40:19 docker dockerd[2309]: time="2024-09-09T21:40:19.587647943+08:00" level=info msg="Defa>
Sep 09 21:40:19 docker dockerd[2309]: time="2024-09-09T21:40:19.881267095+08:00" level=info msg="Load>
Sep 09 21:40:19 docker dockerd[2309]: time="2024-09-09T21:40:19.956577565+08:00" level=info msg="Dock>
Sep 09 21:40:19 docker dockerd[2309]: time="2024-09-09T21:40:19.957045036+08:00" level=info msg="Daem>
Sep 09 21:40:20 docker dockerd[2309]: time="2024-09-09T21:40:20.014584201+08:00" level=info msg="API >
Sep 09 21:40:20 docker systemd[1]: Started Docker Application Container Engine.Docker 镜像
可将 Docker 镜像看着只读模板，通过它可以创建 Docker 容器。
例如某个镜像可能包含一个 Ubuntu 操作系统、一个 Apache HTTP Server 以及用户开发的 Web 应用。
镜像有多种生成方法：
- 可以从无到有开始创建镜像
- 也可以下载并使用别人创建好的现成的镜像
- 还可以在现有镜像上创建新的镜像
我们可以将镜像的内容和创建步骤描述在一个文本文件中，这个文件被称作 Dockerfile，通过执行 docker build <docker-file> 命令可以构建出 Docker 镜像，后面我们会讨论。
Docker 容器
Docker 容器就是 Docker 镜像的运行实例。
用户可以通过 CLI（docker）或是 API 启动、停止、移动或删除容器。可以这么认为，对于应用软件，镜像是软件生命周期的构建和打包阶段，而容器则是启动和运行阶段。
Registry
Registry 是存放 Docker 镜像的仓库，Registry 分私有和公有两种。
Docker Hub（https://hub.docker.com/） 是默认的 Registry，由 Docker 公司维护，上面有数以万计的镜像，用户可以自由下载和使用。
出于对速度或安全的考虑，用户也可以创建自己的私有 Registry。后面我们会学习如何搭建私有 Registry。
docker pull 命令可以从 Registry 下载镜像。
docker run 命令则是先下载镜像（如果本地没有），然后再启动容器。
下一节我们通过一个例子来看各个组件是如何协调工作的。
008 Docker组件如何协作？
还记得我们运行的第一个容器吗？现在通过它来体会一下 Docker 各个组件是如何协作的。
容器启动过程如下：
- Docker 客户端执行
docker run命令。 - Docker daemon 发现本地没有 httpd 镜像。
- daemon 从 Docker Hub 下载镜像。
- 下载完成，镜像 httpd 被保存到本地。
- Docker daemon 启动容器。
docker images 可以查看到 httpd 已经下载到本地。
shell
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
httpd latest 9cb0a2315602 7 weeks ago 148MBdocker ps 或者 docker container ls 显示容器正在运行。
小结
Docker 借鉴了集装箱的概念。标准集装箱将货物运往世界各地，Docker 将这个模型运用到自己的设计哲学中，唯一不同的是：集装箱运输货物，而 Docker 运输软件。
每个容器都有一个软件镜像，相当于集装箱中的货物。容器可以被创建、启动、关闭和销毁。和集装箱一样，Docker 在执行这些操作时，并不关心容器里到底装的什么，它不管里面是 Web Server，还是 Database。
用户不需要关心容器最终会在哪里运行，因为哪里都可以运行。
开发人员可以在笔记本上构建镜像并上传到 Registry，然后 测试人员将镜像下载到物理或虚拟机做测试，最终容器会部署到生产环境。
使用 Docker 以及容器技术，我们可以快速构建一个应用服务器、一个消息中间件、一个数据库、一个持续集成环境。因为 Docker Hub 上有我们能想到的几乎所有的镜像。
不知大家是否意识到，潘多拉盒子已经被打开。容器不但降低了我们学习新技术的门槛，更提高了效率。
如果你是一个运维人员，想研究负载均衡软件 HAProxy，只需要执行docker run haproxy，无需繁琐的手工安装和配置既可以直接进入实战。
如果你是一个开发人员，想学习怎么用 django 开发 Python Web 应用，执行 docker run django，在容器里随便折腾吧，不用担心会搞乱 Host 的环境。
不夸张的说：容器大大提升了 IT 人员的幸福指数。
第3章 镜像
009 最小的镜像
镜像是 Docker 容器的基石，容器是镜像的运行实例，有了镜像才能启动容器。
本章内容安排如下：
- 首先通过研究几个典型的镜像，分析镜像的内部结构。
- 然后学习如何构建自己的镜像。
- 最后介绍怎样管理和分发镜像。
镜像的内部结构
为什么我们要讨论镜像的内部结构？
如果只是使用镜像，当然不需要了解，直接通过 docker 命令下载和运行就可以了。
但如果我们想创建自己的镜像，或者想理解 Docker 为什么是轻量级的，就非常有必要学习这部分知识了。
我们从一个最小的镜像开始吧。
hello-world - 最小的镜像
hello-world 是 Docker 官方提供的一个镜像，通常用来验证 Docker 是否安装成功。
我们先通过 docker pull 从 Docker Hub 下载它。
shell
[root@docker ~]# docker pull hello-world
Using default tag: latest
latest: Pulling from library/hello-world
c1ec31eb5944: Pull complete
Digest: sha256:91fb4b041da273d5a3273b6d587d62d518300a6ad268b28628f74997b93171b2
Status: Downloaded newer image for hello-world:latest
docker.io/library/hello-world:latest用 docker images 命令查看镜像的信息。
shell
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest d2c94e258dcb 16 months ago 13.3kBhello-world 镜像竟然还不到 14KB!
通过 docker run 运行。
shell
[root@docker ~]# docker run hello-world
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/
For more examples and ideas, visit:
https://docs.docker.com/get-started/其实我们更关心 hello-world 镜像包含哪些内容。
Dockerfile 是镜像的描述文件，定义了如何构建 Docker 镜像。Dockerfile 的语法简洁且可读性强，后面我们会专门讨论如何编写 Dockerfile。
hello-world 的 Dockerfile 内容如下：
dockerhub hello-word网页：hello-world - Official Image | Docker Hub
github hello-wrold网页：hello-world/amd64/hello-world at master · docker-library/hello-world · GitHub
只有短短三条指令。
- FROM scratch
此镜像是从白手起家，从 0 开始构建。 - COPY hello /
将文件"hello"复制到镜像的根目录。 - CMD ["/hello"]
容器启动时，执行 /hello
镜像 hello-world 中就只有一个可执行文件 "hello"，其功能就是打印出 "Hello from Docker ..." 等信息。
/hello 就是文件系统的全部内容，连最基本的 /bin，/usr, /lib, /dev 都没有。
hello-world 虽然是一个完整的镜像，但它并没有什么实际用途。通常来说，我们希望镜像能提供一个基本的操作系统环境，用户可以根据需要安装和配置软件。这样的镜像我们称作 base 镜像。
我们下一节讨论 base 镜像。
010 base镜像
上一节我们介绍了最小的 Docker 镜像，本节讨论 base 镜像。
base 镜像有两层含义：
- 不依赖其他镜像，从 scratch 构建。
- 其他镜像可以之为基础进行扩展。
所以，能称作 base 镜像的通常都是各种 Linux 发行版的 Docker 镜像，比如 Ubuntu, Debian, CentOS 等。
我们以 CentOS 为例考察 base 镜像包含哪些内容。
下载镜像：
bash
[root@docker ~]# docker pull centos:7 #下载centos 7查看镜像信息：
shell
[root@docker ~]# docker images centos:7
REPOSITORY TAG IMAGE ID CREATED SIZE
centos 7 eeb6ee3f44bd 3 years ago 204MB镜像大小不到 300MB。
等一下！
一个 CentOS 才 204MB ？
平时我们安装一个 CentOS 至少都有几个 GB，怎么可能才 204MB !
相信这是几乎所有 Docker 初学者都会有的疑问，包括我自己。下面我们来解释这个问题。
Linux 操作系统由内核空间和用户空间组成。如下图所示：
rootfs
内核空间是 kernel，Linux 刚启动时会加载 bootfs 文件系统，之后 bootfs 会被卸载掉。
用户空间的文件系统是 rootfs，包含我们熟悉的 /dev, /proc, /bin 等目录。
对于 base 镜像来说，底层直接用 Host 的 kernel，自己只需要提供 rootfs 就行了。
而对于一个精简的 OS，rootfs 可以很小，只需要包括最基本的命令、工具和程序库就可以了。相比其他 Linux 发行版，CentOS 的 rootfs 已经算臃肿的了，alpine 还不到 10MB。
我们平时安装的 CentOS 除了 rootfs 还会选装很多软件、服务、图形桌面等，需要好几个 GB 就不足为奇了。
base 镜像提供的是最小安装的 Linux 发行版。
下面是 CentOS 镜像的 Dockerfile 的内容：
第二行 ADD 指令添加到镜像的 tar 包就是 CentOS 7 的 rootfs。在制作镜像时，这个 tar 包会自动解压到 / 目录下，生成 /dev, /porc, /bin 等目录。
注：可在 Docker Hub 的镜像描述页面中查看 Dockerfile 。
支持运行多种 Linux OS
不同 Linux 发行版的区别主要就是 rootfs。
比如 Ubuntu 14.04 使用 upstart 管理服务，apt 管理软件包；而 CentOS 7 使用 systemd 和 yum。这些都是用户空间上的区别，Linux kernel 差别不大。
所以 Docker 可以同时支持多种 Linux 镜像，模拟出多种操作系统环境。
上图 Debian 和 BusyBox（一种嵌入式 Linux）上层提供各自的 rootfs，底层共用 Docker Host 的 kernel。
这里需要说明的是：
-
base 镜像只是在用户空间与发行版一致，kernel 版本与发型版是不同的。
例如 ubuntu使用 3.x.x 的 kernel，如果 Docker Host 是 CentOS Stream 8（比如我们的实验环境），那么在 CentOS 容器中使用的实际是是 Host 4.18.0 的 kernel。
bash[root@docker ~]# uname -r 4.18.0-553.6.1.el8.x86_64 #Host OS kernel 为 4.18.0启动一个ubuntu，ubuntu内核正常应该与host os（centos stream 8）不一致
bash[root@docker ~]# docker run -it ubuntu root@4264749aa4af:/# uname -r 4.18.0-553.6.1.el8.x86_64 #容器ubuntu用的内核就是docker host内核启动一个centos:7，centos7正常内核为3.10
bash[root@docker ~]# docker run -it centos:7 [root@72397b60bb10 /]# uname -r 4.18.0-553.6.1.el8.x86_64 -
容器只能使用 Host 的 kernel，并且不能修改。
所有容器都共用 host 的 kernel，在容器中没办法对 kernel 升级。如果容器对 kernel 版本有要求（比如应用只能在某个 kernel 版本下运行），则不建议用容器，这种场景虚拟机可能更合适。
下一节我们讨论镜像的分层结构。
011 镜像的分层结构
Docker 支持通过扩展现有镜像，创建新的镜像。
实际上，Docker Hub 中 99% 的镜像都是通过在 base 镜像中安装和配置需要的软件构建出来的。比如我们现在构建一个新的镜像，Dockerfile 如下：
① 新镜像不再是从 scratch 开始，而是直接在 Debian base 镜像上构建。
② 安装 emacs 编辑器。
③ 安装 apache2。
④ 容器启动时运行 bash。
构建过程如下图所示：
可以看到，新镜像是从 base 镜像一层一层叠加生成的。每安装一个软件，就在现有镜像的基础上增加一层。
问什么 Docker 镜像要采用这种分层结构呢？
最大的一个好处就是 - 共享资源。
比如：有多个镜像都从相同的 base 镜像构建而来，那么 Docker Host 只需在磁盘上保存一份 base 镜像；同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享，我们将在后面更深入地讨论这个特性。
这时可能就有人会问了：如果多个容器共享一份基础镜像，当某个容器修改了基础镜像的内容，比如 /etc 下的文件，这时其他容器的 /etc 是否也会被修改？
答案是不会！
修改会被限制在单个容器内。
这就是我们接下来要学习的容器 Copy-on-Write 特性。
可写的容器层
当容器启动时，一个新的可写层被加载到镜像的顶部。
这一层通常被称作"容器层"，"容器层"之下的都叫"镜像层"。
所有对容器的改动 - 无论添加、删除、还是修改文件都只会发生在容器层中。
只有容器层是可写的，容器层下面的所有镜像层都是只读的。
下面我们深入讨论容器层的细节。
镜像层数量可能会很多，所有镜像层会联合在一起组成一个统一的文件系统。如果不同层中有一个相同路径的文件，比如 /a，上层的 /a 会覆盖下层的 /a，也就是说用户只能访问到上层中的文件 /a。在容器层中，用户看到的是一个叠加之后的文件系统。
对容器增删改差操作如下：
| 操作 | 具体执行 |
|---|---|
| 创建文件 | 新文件只能被添加在容器层中。 |
| 删除文件 | 依据容器分层结构由上往下依次查找。找到后，在容器层中记录该删除操作。 具体实现是，UnionFS会在容器层创建一个"whiteout"文件，将被删除的文件"遮挡"起来。 |
| 修改文件 | 依据容器分层结构由上往下依次查找。找到后，将镜像层中的数据复制到容器层进行修改，修改后的数据保存在容器层中。（copy-on-write） |
| 读取文件 | 依据容器分层结构由上往下依次查找。 |
只有当需要修改时才复制一份数据，这种特性被称作 Copy-on-Write。可见，容器层保存的是镜像变化的部分，不会对镜像本身进行任何修改。
这样就解释了我们前面提出的问题：容器层记录对镜像的修改，所有镜像层都是只读的，不会被容器修改，所以镜像可以被多个容器共享。
理解了镜像的原理和结构，下一节我们学习如何构建镜像。
012 构建镜像
对于 Docker 用户来说，最好的情况是不需要自己创建镜像。几乎所有常用的数据库、中间件、应用软件等都有现成的 Docker 官方镜像或其他人和组织创建的镜像，我们只需要稍作配置就可以直接使用。
使用现成镜像的好处除了省去自己做镜像的工作量外，更重要的是可以利用前人的经验。特别是使用那些官方镜像，因为 Docker 的工程师知道如何更好的在容器中运行软件。
当然，某些情况下我们也不得不自己构建镜像，比如：
- 找不到现成的镜像，比如自己开发的应用程序。
- 需要在镜像中加入特定的功能，比如官方镜像几乎都不提供 ssh。
所以本节我们将介绍构建镜像的方法。同时分析构建的过程也能够加深我们对前面镜像分层结构的理解。
Docker 容器文件系统
描述:从下面的图片可以看见出以下几点：
- Docker 镜像代表了容器的文件系统里的内容，是容器的基础，镜像一般是通过 Dockerfile 生成的；
- Docker 的镜像是分层的，所有的镜像（除了基础镜像）都是在之前镜像的基础上加上自己这层的内容生成的;
- Docker 中每一层镜像的元数据都是存在 json 文件中的，除了静态的文件系统之外，还会包含动态的数据;
- Docker 镜像生产容器后会在此基础之上加入挂载点到安装Docker宿主机文件系统之中，并提供一个读写层(Read-Write Layer)，所以容器进程的所有操作都在读写层进行;
Docker 提供了两种构建镜像的方法：
- docker commit 命令
- Dockerfile 构建文件
docker commit
docker commit 命令是创建新镜像最直观的方法，其过程包含三个步骤：
- 运行容器
- 修改容器
- 将容器保存为新的镜像
举个例子：在 ubuntu base 镜像中安装 vim并保存为新镜像。
-
第一步， 运行容器
shell[root@docker ~]# docker run -it ubuntu root@8dbdff6d3d88:/#-it参数的作用是以交互模式进入容器，并打开终端。d11014d4b667是容器的内部 ID。 -
安装 vim
确认 vim 没有安装。
shellroot@8dbdff6d3d88:/# vim bash: vim: command not found安装 vim。
shellroot@8dbdff6d3d88:/# apt-get update root@8dbdff6d3d8:/# apt-get install -y vim 1. Africa 2. America 3. Antarctica 4. Arctic 5. Asia 6. Atlantic 7. Australia 8. Europe 9. Indian 10. Pacific 11. Etc Geographic area: 5 Please select the city or region corresponding to your time zone. 1. Aden 12. Bangkok 23. Dili 34. Istanbul 45. Krasnoyarsk 56. Novosibirsk 67. Samarkand 78. Tokyo 2. Almaty 13. Barnaul 24. Dubai 35. Jakarta 46. Kuala_Lumpur 57. Omsk 68. Seoul 79. Tomsk 3. Amman 14. Beirut 25. Dushanbe 36. Jayapura 47. Kuching 58. Oral 69. Shanghai 80. Ulaanbaatar 4. Anadyr 15. Bishkek 26. Famagusta 37. Jerusalem 48. Kuwait 59. Phnom_Penh 70. Singapore 81. Urumqi 5. Aqtau 16. Brunei 27. Gaza 38. Kabul 49. Macau 60. Pontianak 71. Srednekolymsk 82. Ust-Nera 6. Aqtobe 17. Chita 28. Harbin 39. Kamchatka 50. Magadan 61. Pyongyang 72. Taipei 83. Vientiane 7. Ashgabat 18. Choibalsan 29. Hebron 40. Karachi 51. Makassar 62. Qatar 73. Tashkent 84. Vladivostok 8. Atyrau 19. Chongqing 30. Ho_Chi_Minh 41. Kashgar 52. Manila 63. Qostanay 74. Tbilisi 85. Yakutsk 9. Baghdad 20. Colombo 31. Hong_Kong 42. Kathmandu 53. Muscat 64. Qyzylorda 75. Tehran 86. Yangon 10. Bahrain 21. Damascus 32. Hovd 43. Khandyga 54. Nicosia 65. Riyadh 76. Tel_Aviv 87. Yekaterinburg 11. Baku 22. Dhaka 33. Irkutsk 44. Kolkata 55. Novokuznetsk 66. Sakhalin 77. Thimphu 88. Yerevan Time zone: 69 -
保存为新镜像
打开一个新窗口中查看当前运行的容器。
bash
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
8dbdff6d3d88 ubuntu "/bin/bash" 2 minutes ago Up 2 minutes cool_darwin上面查看结果的解释如下：
8dbdff6d3d88 是新创建容器的ID
cool_darwin 是 Docker 为我们的容器随机分配的名字。
执行 docker commit 命令将容器保存为镜像。
一定要保证容器正在运行
shell
[root@docker ~]# docker commit cool_darwin ubuntu-with-vim #cool_darwin是容器名,ubuntu-with-vim是新建的镜像名
sha256:ba18ae460c068f9bdba060350e64dcec4bc4af05b9918602ee34e6350d0369a4新镜像命名为 ubuntu-with-vim。
查看新镜像的属性。
bash
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu-with-vim latest acefd029083b 27 minutes ago 189MB
ubuntu latest edbfe74c41f8 5 weeks ago 78.1MB从 size 上看到镜像因为安装了软件而变大了。
从新镜像启动容器，验证 vim 已经可以使用。
shell
[root@docker ~]# docker run -it ubuntu-with-vim #ubuntu-with-vim是新创建的镜像名
root@4d071cf3014f:/# which vim
/usr/bin/vim
root@4d071cf3014f:/# vim file1以上演示了如何用 docker commit 创建新镜像。然而，Docker 并不建议用户通过这种方式构建镜像。原因如下：
- 这是一种手工创建镜像的方式，容易出错，效率低且可重复性弱。比如要在 debian base 镜像中也加入 vim，还得重复前面的所有步骤。
- 更重要的：使用者并不知道镜像是如何创建出来的，里面是否有恶意程序。也就是说无法对镜像进行审计，存在安全隐患。
既然 docker commit 不是推荐的方法，我们干嘛还要花时间学习呢？
原因是：即便是用 Dockerfile（推荐方法）构建镜像，底层也 docker commit 一层一层构建新镜像的。学习 docker commit 能够帮助我们更加深入地理解构建过程和镜像的分层结构。
下一节我们学习如何通过 Dockerfile 构建镜像。
013 Dockerfile构建镜像
Dockerfile 是一个文本文件，记录了镜像构建的所有步骤。
Dockerfile内容基础知识：
- 每条保留字指令都必须为大写字母且后面要跟随至少一个参数
- 指令按照从上到下，顺序执行
- #表示注释
- 每条指令都会创建一个新的镜像层并对镜像进行提交
常用参数：
docker build -f [Dockerfile路径] [构建上下文路径]| 参数 | 作用 |
|---|---|
-f 或 --file |
标志符，声明要使用自定义 Dockerfile |
[Dockerfile路径] |
绝对路径 或相对于构建上下文的路径 （如 subdir/Dockerfile.dev） |
[构建上下文路径] |
Docker 打包发送给守护进程的目录（通常用 . 表示当前目录） |
第一个 Dockerfile
用 Dockerfile 创建上节的 ubuntu-with-vim，其内容则为：
下面我们运行 docker build 命令构建镜像并详细分析每个细节。
bash
[root@docker ~]# cd /root #生产环境一般新建一个目录，里面写Dockerfile
[root@docker ~]# vim Dockerfile
FROM ubuntu
RUN apt-get update && apt-get install -y vim
[root@docker ~]# docker build -t ubuntu-with-vim-dockerfile .
① 当前目录为 /root。
② Dockerfile 准备就绪。
③ 运行 docker build 命令，-t 将新镜像命名为 ubuntu-with-vim-dockerfile，命令末尾的 . 指明 build context 为当前目录。Docker 默认会从 build context 中查找 Dockerfile 文件，我们也可以通过 -f 参数指定 Dockerfile 的位置。
④ 从这步开始就是镜像真正的构建过程。 首先 Docker 将 build context 中的所有文件发送给 Docker daemon。build context 为镜像构建提供所需要的文件或目录。
Dockerfile 中的 ADD、COPY 等命令可以将 build context 中的文件添加到镜像。此例中，build context 为当前目录 /root，该目录下的所有文件和子目录都会被发送给 Docker daemon。
所以，使用 build context 就得小心了，不要将多余文件放到 build context，特别不要把 /、/usr 作为 build context，否则构建过程会相当缓慢甚至失败。
⑤ Step 1：执行 FROM，将 ubuntu 作为 base 镜像。
⑥ Step 2：执行 RUN，安装 vim
⑦ 镜像构建成功。
⑧ 镜像重命名为ubuntu-with-vim-dockerfile
通过 docker images 查看镜像信息。
shell
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu-with-vim-dockerfile latest bbc08145d011 10 minutes ago 189MB
ubuntu-with-vim latest acefd029083b 27 minutes ago 189MB
ubuntu latest edbfe74c41f8 5 weeks ago 78.1MB镜像 ID 为 bbc08145d011，与构建时的输出一致。
在上面的构建过程中，我们要特别注意指令 RUN 的执行过程。Docker 会在启动的临时容器中执行操作，并通过 commit 保存为新的镜像。
查看镜像分层结构
ubuntu-with-vim-dockerfile 是通过在 base 镜像的顶部添加一个新的镜像层而得到的。
这个新镜像层的内容由 RUN apt-get update && apt-get install -y vim 生成。这一点我们可以通过 docker history 命令验证。
docker history 会显示镜像的构建历史，也就是 Dockerfile 的执行过程。
ubuntu-with-vi-dockerfile 与 ubuntu 镜像相比，确实只是多了顶部的一层 bbc08145d011，由 apt-get 命令创建，大小为 111MB。docker history 也向我们展示了镜像的分层结构，每一层由上至下排列。
注： 表示无法获取 IMAGE ID，通常从 Docker Hub 下载的镜像会有这个问题。
下一节我们学习镜像的缓存特性。
014 镜像的缓存特性
上一节我们学习了镜像的分层结构，接下来讨论镜像的缓存特性。
Docker 会缓存已有镜像的镜像层，构建新镜像时，如果某镜像层已经存在，就直接使用，无需重新创建。
举例说明。
在前面的 Dockerfile 中添加一点新内容，往镜像中复制一个文件：
bash
[root@docker ~]# pwd
/root
[root@docker ~]# ls
Dockerfile
[root@docker ~]# touch testfile
[root@docker ~]# ls
Dockerfile testfile
[root@docker ~]# vim Dockerfile
[root@docker ~]# cat Dockerfile
FROM ubuntu
RUN apt-get update && apt-get install -y vim
COPY testfile /
[root@docker ~]# docker build -t ubuntu-with-vim-dockerfile-2 .
① 确保 testfile 已存在。可以通过touch创建
② 重点在这里：之前已经运行过相同的 RUN 指令，这次直接使用缓存中的镜像层
③ 执行 COPY 指令。
其过程是启动临时容器，复制 testfile，提交新的镜像层5561217926be，删除临时容器。
在 ubuntu-with-vi-dockerfile 镜像上直接添加一层就得到了新的镜像 ubuntu-with-vim-dockerfile-2。
如果我们希望在构建镜像时不使用缓存，可以在 docker build 命令中加上 --no-cache 参数。
Dockerfile 中每一个指令都会创建一个镜像层，上层是依赖于下层的。无论什么时候，只要某一层发生变化，其上面所有层的缓存都会失效。
也就是说，如果我们改变 Dockerfile 指令的执行顺序，或者修改或添加指令，都会使缓存失效。
举例说明，比如交换前面 RUN 和 COPY 的顺序：
虽然在逻辑上这种改动对镜像的内容没有影响，但由于分层的结构特性，Docker 必须重建受影响的镜像层。
bash
[root@docker ~]# vim Dockerfile
FROM ubuntu
COPY testfile /
RUN apt-get update && apt-get install -y vim
[root@docker ~]# docker build -t ubuntu-with-vim-dockerfile-3 .
从上面的输出可以看到[2/3],[3/3]都没有使用缓存，最后生成了新的镜像层 33f20b2ec8fd，缓存已经失效。
除了构建时使用缓存，Docker 在下载镜像时也会使用。例如我们下载 httpd 镜像。
docker pull 命令输出显示第一层（base 镜像）已经存在，不需要下载。
由 Dockerfile 可知 httpd 的 base 镜像为 debian，正好之前已经下载过 debian 镜像，所以有缓存可用。通过 docker history 可以进一步验证。
下一节我们学习如何调试 Dockerfile。
015 调试Dockerfile
包括 Dockerfile 在内的任何脚本和程序都会出错。有错并不可怕，但必须有办法排查，所以本节讨论如何 debug Dockerfile。
先回顾一下通过 Dockerfile 构建镜像的过程：
- 从 base 镜像运行一个容器。
- 执行一条指令，对容器做修改。
- 执行类似 docker commit 的操作，生成一个新的镜像层。
- Docker 再基于刚刚提交的镜像运行一个新容器。
- 重复 2-4 步，直到 Dockerfile 中的所有指令执行完毕。
从这个过程可以看出，如果 Dockerfile 由于某种原因执行到某个指令失败了，我们也将能够得到前一个指令成功执行构建出的镜像，这对调试 Dockerfile 非常有帮助。我们可以运行最新的这个镜像定位指令失败的原因。
我们来看一个调试的例子。Dockerfile 内容如下：
执行 docker build：
bash
[root@docker ~]# ls #查看下有没有Dockerfile和testfile
Dockerfile testfile
[root@docker ~]# vim Dockerfile #编辑Dockerfile，写入上图的内容
FROM busybox
RUN touch tmpfile
RUN /bin/bash -c "echo continue to build..."
COPY testfile /
[root@docker ~]# docker build -t image-debug . #基于刚才写的Dockerfile构建镜像image-debug
Dockerfile 在执行第三步 RUN 指令时失败。我们可以利用busybox的镜像进行调试，方式是通过 docker run -it 启动镜像的一个容器。
手工执行 RUN 指令很容易定位失败的原因是 busybox 镜像中没有 bash，busybox中用的是sh。虽然这是个极其简单的例子，但它很好地展示了调试 Dockerfile 的方法。
bash
# 找出错误原因，修改错误
[root@docker ~]# cat Dockerfile
FROM busybox
RUN touch tmpfile
RUN /bin/sh -c "echo continue to builld..." #将错误的/bin/bash修改为正确的/bin/sh
COPY testfile /
[root@docker ~]# docker build -t image-debug . #基于刚才写的Dockerfile构建镜像image-debug成功了！
到这里相信大家对 Dockerfile 的功能和使用流程有了比较完整的印象，但还没有系统学习 Dockerfile 的各种指令和实际用法，下节会开始这个主题。
016 Dockerfile常用指令
是时候系统学习 Dockerfile 了。
下面列出了 Dockerfile 中最常用的指令，完整列表和说明可参看官方文档。
FROM
指定 base 镜像。第一条必须是FROM
MAINTAINER
设置镜像的作者，可以是任意字符串。
COPY
将文件从 build context 复制到镜像。
COPY 支持两种形式：
- COPY src dest
- COPY ["src", "dest"]
注意：src 只能指定 build context 中的文件或目录。
ADD
与 COPY 类似，从 build context 复制文件到镜像。不同的是，如果 src 是归档文件（tar, zip, tgz, xz 等），文件会被自动解压到 dest。
ENV
设置环境变量，环境变量可被后面的指令使用。例如：
dockerfile
...
ENV MY_VERSION 1.3
RUN apt-get install -y mypackage=$MY_VERSION
...EXPOSE
指定容器中的进程会监听某个端口，Docker 可以将该端口暴露出来。我们会在容器网络部分详细讨论。
VOLUME
将文件或目录声明为 volume。我们会在容器存储部分详细讨论。
WORKDIR
为后面的 RUN, CMD, ENTRYPOINT, ADD 或 COPY 指令设置镜像中的当前工作目录。
RUN
构建镜像层的命令。
CMD
容器启动时运行指定的命令。
Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效。CMD 可以被 docker run 之后的参数替换。
ENTRYPOINT
设置容器启动时运行的命令。
Dockerfile 中可以有多个 ENTRYPOINT 指令，但只有最后一个生效。CMD 或 docker run 之后的参数会被当做参数传递给 ENTRYPOINT。
下面我们来看一个较为全面的 Dockerfile：
dockerfile
# my dockerfile
FROM busybox #从busybox开始构建
MAINTAINER 6946630@qq.com #声明作者信息
WORKDIR /testdir #设置工作目录为/testdir
RUN touch tmpfile1 #在新镜像中创建tmpfille1
COPY ["tmpfile2","."] #将Dockerfile文件所在目录中的tmpfile2文件拷贝到新镜像中
ADD ["passwd.tar.gz","."] #将Dockerfile文件所在目录中的passwd.tar.gz拷贝到新镜像中并解压缩
ENV WELCOME "You are in my container,welcome!" #设置环境变老了WELOCME完整的操作步骤如下：
bash
[root@docker ~]# pwd #确定Dockerfile工作目录
/root
[root@docker ~]# ls #当前/root目录下空的
[root@docker ~]# touch tmpfile2 #创建空文档tmpfile2
[root@docker ~]# cp /etc/passwd . #将/etc/passwd文件拷贝到/root
[root@docker ~]# tar -cvzf passwd.tar.gz passwd #将passwd文件做出归档文件passwd.tar.gz
passwd
[root@docker ~]# rm passwd #删除passwd文件
rm: remove regular file 'passwd'? y
[root@docker ~]# vim Dockerfile #编辑Dockerfile写入如下内容
# my dockerfile
FROM busybox
MAINTAINER 6946630@qq.com
WORKDIR /testdir
RUN touch tmpfile1
COPY ["tmpfile2","."]
ADD ["passwd.tar.gz","."]
ENV WELCOME "You are in my container,welcome!"
[root@docker ~]# ls #最后目录中有三个文件
Dockerfile passwd.tar.gz tmpfile2
[root@docker ~]# docker build -t my-image . #构建新镜像my-image
① 构建前确保 build context 中存在需要的文件。
② 依次执行 Dockerfile 指令，完成构建。
运行容器，验证镜像内容：
① 进入容器，当前目录即为 WORKDIR。
如果 WORKDIR 不存在，Docker 会自动为我们创建。
② WORKDIR 中保存了我们希望的文件和目录：
文件passwd：由 ADD 指令从 build context 复制的归档文件passwd.tar.gz，已经自动解压。
文件 tmpfile1：由 RUN 指令创建。
文件 tmpfile2：由 COPY 指令从 build context 复制。
③ ENV 指令定义的环境变量已经生效。
在上面这些指令中，RUN、CMD、ENTRYPOINT 很重要且容易混淆，下节专门讨论。
017 RUN vs CMD vs ENTRYPOINT
RUN、CMD 和 ENTRYPOINT 这三个 Dockerfile 指令看上去很类似，很容易混淆。本节将通过实践详细讨论它们的区别。
简单的说：
- RUN 执行命令并创建新的镜像层，RUN 经常用于安装软件包。
- CMD 设置容器启动后默认执行的命令及其参数，但 CMD 能够被
docker run后面跟的命令行参数替换。 - ENTRYPOINT 配置容器启动时运行的命令。
下面我们详细分析。
Shell 和 Exec 格式
我们可用两种方式指定 RUN、CMD 和 ENTRYPOINT 要运行的命令：Shell 格式和 Exec 格式，二者在使用上有细微的区别。
Shell 格式
bash
<instruction> <command>例如：
dockerfile
RUN apt-get install python3
CMD echo "Hello world"
ENTRYPOINT echo "Hello world" 当指令执行时，shell 格式底层会调用 /bin/sh -c 。
例如下面的 Dockerfile ：
dockerfile
[root@docker ~]# vim Dockerfile
FROM busybox
ENV name dcr
ENTRYPOINT echo "Hello, $name" 用上面的Dockerfile创建镜像dockerfile1用于测试
bash
[root@docker ~]# docker build -t dockerfile1 .执行 docker run dockerfile1：
bash
[root@docker ~]# docker run dockerfile1
Hello,dcr注意环境变量 name 已经被值 dcr 替换。
下面来看 Exec 格式。
Exec 格式
bash
<instruction> ["executable", "param1", "param2", ...]例如：
dockerfile
RUN ["apt-get", "install", "python3"]
CMD ["/bin/echo", "Hello world"]
ENTRYPOINT ["/bin/echo", "Hello world"]当指令执行时，会直接调用 ，不会被 shell 解析。
例如下面的 Dockerfile ：
dockerfile
[root@docker ~]# vim Dockerfile
FROM busybox
ENV name dcr
ENTRYPOINT ["/bin/echo", "Hello, $name"]用上面的Dockerfile创建镜像dockerfile2用于测试
bash
[root@docker ~]# docker build -t dockerfile2 .执行 docker run dockerfile2：
bash
[root@docker ~]# docker run dockerfile2
hello,$name注意环境变量"name"没有被替换。
如果希望使用环境变量，照如下修改
dockerfile
[root@docker ~]# vim Dockerfile
FROM busybox
ENV name dcr
ENTRYPOINT ["/bin/sh", "-c", "echo Hello, $name"]用上面的Dockerfile创建镜像dockerfile3用于测试
bash
[root@docker ~]# docker build -t dockerfile3 .执行 docker run dockerfile3：
bash
[root@docker ~]# docker run dockerfile3
Hello, dcrCMD 和 ENTRYPOINT 推荐使用 Exec 格式，因为指令可读性更强，更容易理解。RUN 则两种格式都可以。
RUN
RUN 指令通常用于安装应用和软件包。
RUN 在当前镜像的顶部执行命令，并通过创建新的镜像层。Dockerfile 中常常包含多个 RUN 指令。
RUN 有两种格式：
- Shell 格式：RUN
- Exec 格式：RUN ["executable", "param1", "param2"]
下面的Dockerfile是使用 RUN 安装多个包的例子：
dockerfile
[root@docker ~]# vim Dockerfile
FROM ubuntu
RUN apt-get update && apt-get install -y \
bzr \
cvs \
git \
mercurial \
subversion用上面的Dockerfile创建镜像dockerfile4用于测试
bash
[root@docker ~]# docker build -t dockerfile4 .执行 docker run -it dockerfile4：
bash
[root@docker ~]# docker run -it dockerfile4
root@43894b9f29db:/# apt list install brz cvs git mercurial subversion
Listing... Done
brz/noble,now 3.3.5-6build2 amd64 [installed,automatic]
cvs/noble,now 2:1.12.13+real-30build1 amd64 [installed]
git/noble-updates,noble-security,now 1:2.43.0-1ubuntu7.3 amd64 [installed]
mercurial/noble-updates,now 6.7.2-1ubuntu2.2 amd64 [installed]
subversion/noble,now 1.14.3-1build4 amd64 [installed]注意：apt-get update 和 apt-get install 被放在一个 RUN 指令中执行，这样能够保证每次安装的是最新的包。如果 apt-get install 在单独的 RUN 中执行，则会使用 apt-get update 创建的镜像层，而这一层可能是很久以前缓存的。
CMD
CMD 指令允许用户指定容器的默认执行的命令。
此命令会在容器启动且 docker run 没有指定其他命令时运行。
- 如果 docker run 指定了其他命令，CMD 指定的默认命令将被忽略。
- 如果 Dockerfile 中有多个 CMD 指令，只有最后一个 CMD 有效。
CMD 有三种格式：
- Exec 格式：CMD ["executable","param1","param2"] 这是 CMD 的推荐格式。
- CMD ["param1","param2"] 为 ENTRYPOINT 提供额外的参数，此时 ENTRYPOINT 必须使用 Exec 格式。
- Shell 格式：CMD command param1 param2
Exec 和 Shell 格式前面已经介绍过了。
第二种格式 CMD ["param1","param2"] 要与 Exec 格式 的 ENTRYPOINT 指令配合使用，其用途是为 ENTRYPOINT 设置默认的参数。我们将在后面讨论 ENTRYPOINT 时举例说明。
下面看看 CMD 是如何工作的。Dockerfile 如下：
dockerfile
[root@docker ~]# vim Dockerfile
FROM busybox
CMD echo "Hello,world"用上面的Dockerfile创建镜像dockerfile5用于测试
bash
[root@docker ~]# docker build -t dockerfile5 .运行容器docker run -it dockerfile5将输出：
bash
[root@docker ~]# docker run -it dockerfile5
Hello,world但当后面加上一个命令，比如docker run -it dockerfile5 /bin/sh，CMD 会被忽略掉，命令 sh 将被执行：
bash
[root@docker ~]# docker run -it dockerfile5 /bin/sh
/ #ENTRYPOINT
ENTRYPOINT 指令可让容器以应用程序或者服务的形式运行。
ENTRYPOINT 看上去与 CMD 很像，它们都可以指定要执行的命令及其参数。不同的地方在于 ENTRYPOINT 不会被忽略，一定会被执行，即使运行 docker run 时指定了其他命令。
ENTRYPOINT 有两种格式：
- Exec 格式：ENTRYPOINT ["executable", "param1", "param2"] 这是 ENTRYPOINT 的推荐格式。
- Shell 格式：ENTRYPOINT command param1 param2
在为 ENTRYPOINT 选择格式时必须小心，因为这两种格式的效果差别很大。
Exec 格式
ENTRYPOINT 的 Exec 格式用于设置要执行的命令及其参数，同时可通过 CMD 提供额外的参数。
ENTRYPOINT 中的参数始终会被使用，而 CMD 的额外参数可以在容器启动时动态替换掉。
比如下面的 Dockerfile ：
dockerfile
[root@docker ~]# vim Dockerfile
FROM busybox
ENTRYPOINT ["/bin/echo", "Hello"]
CMD ["world"]用上面的Dockerfile创建镜像dockerfile6用于测试
bash
[root@docker ~]# docker build -t dockerfile6 .当容器通过 docker run -it dockerfile6 启动时，输出为：
bash
[root@docker ~]# docker run -it dockerfile6
Hello world而如果通过 docker run -it dockerfile6 dcr 启动，则输出为：
bash
[root@docker ~]# docker run -it dockerfile6 dcr
Hello dcrShell 格式
ENTRYPOINT 的 Shell 格式会忽略任何 CMD 或 docker run 提供的参数。
比如下面的 Dockerfile ：
dockerfile
FROM busybox
ENTRYPOINT echo "Hello"
CMD ["world"]用上面的Dockerfile创建镜像dockerfile7用于测试
bash
[root@docker ~]# docker build -t dockerfile7 .当容器通过 docker run -it dockerfile7 启动时，输出为：
bash
[root@docker ~]# docker run -it dockerfile7
Hello,而如果通过 docker run -it dockerfile7 dcr 启动，则输出为：
bash
[root@docker ~]# docker run -it dockerfile7 dcr
Hello,Shell 格式
最佳实践
- 使用 RUN 指令安装应用和软件包，构建镜像。
- 如果 Docker 镜像的用途是运行应用程序或服务，比如运行一个 MySQL，应该优先使用 Exec 格式的 ENTRYPOINT 指令。CMD 可为 ENTRYPOINT 提供额外的默认参数，同时可利用 docker run 命令行替换默认参数。
- 如果想为容器设置默认的启动命令，可使用 CMD 指令。用户可在 docker run 命令行中替换此默认命令。
到这里，我们已经具备编写 Dockerfile 的能力了。如果大家还觉得没把握，推荐一个快速掌握 Dockerfile 的方法：去 Docker Hub 上参考那些官方镜像的 Dockerfile。
好了，我们已经学习完如何创建自己的 image，下一节讨论如何分发 image。
Dockerfile案例：配置SSH镜像
项目背景：官方下载的centos镜像默认不带ssh，管理起来不方便，自己制作一个带SSH功能的centos镜像
创建dockerfile
dockerfile
[root@docker ~]# vim centos.ssh.dockerfile
FROM centos:8.4.2105
MAINTAINER dcr
RUN minorver=8.4.2105 && \
sed -e "s|^mirrorlist=|#mirrorlist=|g" \
-e "s|^#baseurl=http://mirror.centos.org/\$contentdir/\$releasever|baseurl=https://mirrors.aliyun.com/centos-vault/$minorver|g" \
-i.bak \
/etc/yum.repos.d/CentOS-*.repo
RUN yum install -y openssh-server
RUN ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key
RUN ssh-keygen -t ecdsa -f /etc/ssh/ssh_host_ecdsa_key
RUN echo "root:huawei" | chpasswd
EXPOSE 22
CMD ["/usr/sbin/sshd","-D"]构建镜像
bash
[root@docker ~]# docker build -t centos:ssh -f centos.ssh.dockerfile .
[+] Building 0.6s (10/10) FINISHED docker:default
=> [internal] load build definition from centos.ssh.dockerfile 0.0s
=> => transferring dockerfile: 604B 0.0s
=> [internal] load metadata for docker.io/library/centos:8.4.2105 0.0s
=> [internal] load .dockerignore 0.0s
=> => transferring context: 2B 0.0s
=> [1/6] FROM docker.io/library/centos:8.4.2105 0.0s
=> CACHED [2/6] RUN minorver=8.4.2105 && sed -e "s|^mirrorlist=|#mirrorlist=|g" -e "s|^#baseurl=http://mirror.centos.org/$contentdir/$releasever|baseurl=h 0.0s
=> CACHED [3/6] RUN yum install -y openssh-server 0.0s
=> CACHED [4/6] RUN ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key 0.0s
=> [5/6] RUN ssh-keygen -t ecdsa -f /etc/ssh/ssh_host_ecdsa_key 0.3s
=> [6/6] RUN echo "root:huawei" | chpasswd 0.3s
=> exporting to image 0.0s
=> => exporting layers 0.0s
=> => writing image sha256:cc138c4d3c36fe82eab32dd80549707c8bfe99ddcb6d3882319a10283bb1a864 0.0s
=> => naming to docker.io/library/centos:ssh 查看现象
bash
[root@docker ~]# docker history centos:ssh
IMAGE CREATED CREATED BY SIZE COMMENT
cc138c4d3c36 36 seconds ago CMD ["/usr/sbin/sshd" "-D"] 0B buildkit.dockerfile.v0
<missing> 36 seconds ago EXPOSE map[22/tcp:{}] 0B buildkit.dockerfile.v0
<missing> 36 seconds ago RUN /bin/sh -c echo "root:huawei" | chpasswd... 1.77kB buildkit.dockerfile.v0
<missing> 36 seconds ago RUN /bin/sh -c ssh-keygen -t ecdsa -f /etc/s... 695B buildkit.dockerfile.v0
<missing> 47 minutes ago RUN /bin/sh -c ssh-keygen -t rsa -f /etc/ssh... 3.18kB buildkit.dockerfile.v0
<missing> 47 minutes ago RUN /bin/sh -c yum install -y openssh-server... 51.9MB buildkit.dockerfile.v0
<missing> About an hour ago RUN /bin/sh -c minorver=8.4.2105 && sed -e "... 17.6kB buildkit.dockerfile.v0
<missing> About an hour ago MAINTAINER dcr 0B buildkit.dockerfile.v0
<missing> 3 years ago /bin/sh -c #(nop) CMD ["/bin/bash"] 0B
<missing> 3 years ago /bin/sh -c #(nop) LABEL org.label-schema.sc... 0B
<missing> 3 years ago /bin/sh -c #(nop) ADD file:805cb5e15fb6e0bb0... 231MB测试
bash
#基于刚才dockerfile创建的镜像centos:ssh创建容器sshtest
[root@docker ~]# docker run -d -p 2022:22 --name sshtest centos:ssh
73d963d15407a1e73097540bb320b9edf05b468001bd707abf01bc7be5e54bcb
#创建出来的容器
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
73d963d15407 centos:ssh "/usr/sbin/sshd -D" 6 seconds ago Up 5 seconds 0.0.0.0:2022->22/tcp, :::2022->22/tcp sshtest
#ssh登录容器测试ssh，能够成功登录
[root@docker ~]# ssh root@localhost -p 2022
The authenticity of host '[localhost]:2022 ([::1]:2022)' can't be established.
ECDSA key fingerprint is SHA256:z1owYLOuClnbPrZwXxgy1jcItQT1k+QX6LxosydT64A.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[localhost]:2022' (ECDSA) to the list of known hosts.
root@localhost's password:
"System is booting up. Unprivileged users are not permitted to log in yet. Please come back later. For technical details, see pam_nologin(8)."
[root@73d963d15407 ~]#Dockerfile案例：自定义httpd镜像
创建dockerfile
dockerfile
[root@docker ~]# vim httpd.dockerfile
FROM centos:8.4.2105
MAINTAINER dcr
RUN minorver=8.4.2105 \
&& sed -e "s|^mirrorlist=|#mirrorlist=|g" -e "s|^#baseurl=http://mirror.centos.org/\$contentdir/\$releasever|baseurl=https://mirrors.aliyun.com/centos-vault/$minorver|g" -i.bak /etc/yum.repos.d/CentOS-*.repo
RUN yum install -y httpd && yum clean all && rm -rf /var/cache/yum
COPY index.html /var/www/html/
EXPOSE 80
CMD ["/usr/sbin/httpd", "-DFOREGROUND"]
[root@docker ~]# echo Hello World > index.html构建镜像
bash
[root@docker ~]# docker build -t httpd:centos -f httpd.dockerfile .查看现象
bash
[root@docker ~]# docker history httpd:centos测试
bash
#基于刚才dockerfile创建的镜像httpd:centos创建容器myweb
[root@docker ~]# docker run -d -p 80:80 --name myweb httpd:centos
1e0b0631cf708bcc0a162d56b936a12cd06c9bcdebcc2594b23c2fbee3ed8894
#创建出来的容器
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
1e0b0631cf70 httpd:centos "/usr/sbin/httpd -DF..." About a minute ago Up About a minute 0.0.0.0:80->80/tcp, :::80->80/tcp myweb
#访问测试
[root@docker ~]# curl localhost
Hello WorldDockerfile案例：自定义mycentosjava8
项目背景：java工程师需要我们给他发个带JAVA的centos
要求CentOS8镜像具备vim+ifconfig+jdk8
JDK的下载地址：https://www.oracle.com/java/technologies/downloads/#java8
编写Dockerfile文件
bash
[root@docker ~]# mkdir myfile ; cd myfile
[root@docker myfile]# vim Dockerfile
dockerfile
FROM centos:8.4.2105
MAINTAINER dcr<123@qq.com>
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置yum源
RUN minorver=8.4.2105 \
&& sed -e "s|^mirrorlist=|#mirrorlist=|g" -e "s|^#baseurl=http://mirror.centos.org/\$contentdir/\$releasever|baseurl=https://mirrors.aliyun.com/centos-vault/$minorver|g" -i.bak /etc/yum.repos.d/CentOS-*.repo
#安装vim编辑器
RUN yum -y install vim
#安装ifconfig命令查看网络IP
RUN yum -y install net-tools
#安装java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把jdk-8u461-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ADD jdk-8u461-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_461
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH
EXPOSE 80
CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash
bash
# 将jdk-8u461-linux-x64.tar.gz与Dockerfile放到同一目录
[root@docker myfile]# ls
Dockerfile jdk-8u461-linux-x64.tar.gz
bash
# 构建镜像为centosjava8:461
[root@docker myfile]# docker build -t centosjava8:461 .
查看构建的镜像
bash
[root@docker myfile]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
centosjava8 461 8097b762c0a5 4 minutes ago 537MB用创建的镜像运行容器测试
bash
[root@docker myfile]# docker run -it centosjava8:461 /bin/bash
[root@6b2767bcdf24 local]# pwd #测试了ENV和WORKDIR
/usr/local
[root@6b2767bcdf24 local]# java -version #测试java是否安装
java version "1.8.0_461"
Java(TM) SE Runtime Environment (build 1.8.0_461-b11)
Java HotSpot(TM) 64-Bit Server VM (build 25.461-b11, mixed mode)
[root@6b2767bcdf24 local]# ifconfig #测试net-tools是否安装
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 172.17.0.3 netmask 255.255.0.0 broadcast 172.17.255.255
ether 02:42:ac:11:00:03 txqueuelen 0 (Ethernet)
RX packets 8 bytes 656 (656.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10<host>
loop txqueuelen 1000 (Local Loopback)
RX packets 0 bytes 0 (0.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
[root@6b2767bcdf24 local]#vim file1 #测试vim是否安装018 镜像命名的最佳实践
我们已经学会构建自己的镜像了。接下来的问题是如何在多个 Docker Host 上使用镜像。
这里有几种可用的方法：
- 用相同的 Dockerfile 在其他 host 构建镜像。
- 将镜像上传到公共 Registry（比如 Docker Hub），Host 直接下载使用。
- 搭建私有的 Registry 供本地 Host 使用。
第一种方法没什么特别的，前面已经讨论很多了。我们将讨论如何使用公共和私有 Registry 分发镜像。
为镜像命名
无论采用何种方式保存和分发镜像，首先都得给镜像命名。
当我们执行 docker build命令时已经为镜像取了个名字，例如前面：
docker build -t ubuntu-with-vim
这里的 ubuntu-with-vim 就是镜像的名字。通过 dock images 可以查看镜像的信息。
这里注意到 ubuntu-with-vim 对应的是 REPOSITORY ，而且还有一个叫 latest 的 TAG。
实际上一个特定镜像的名字由两部分组成：repository 和 tag。
[image name] = [repository]:[tag]
全称如下：
镜像名称格式:Image hub address/Namespace/Repository:tag即054b8ac70e8010d90f2ac00ef29e6580.mirror.swr.myhuaweicloud.com/library/nginx:latest
如果执行 docker build 时没有指定 tag，会使用默认值 latest。其效果相当于：
docker build -t ubuntu-with-vim:latest
tag 常用于描述镜像的版本信息，比如 httpd 镜像：
当然 tag 可以是任意字符串，比如 ubuntu 镜像：
小心 latest tag
千万别被 latest tag 给误导了。latest 其实并没有什么特殊的含义。当没指明镜像 tag 时，Docker 会使用默认值 latest，仅此而已。
虽然 Docker Hub 上很多 repository 将 latest 作为最新稳定版本的别名，但这只是一种约定，而不是强制规定。
所以我们在使用镜像时最好还是避免使用 latest，明确指定某个 tag，比如 httpd:2.3，ubuntu:xenial。
tag 使用最佳实践
借鉴软件版本命名方式能够让用户很好地使用镜像。
一个高效的版本命名方案可以让用户清楚地知道当前使用的是哪个镜像，同时还可以保持足够的灵活性。
每个 repository 可以有多个 tag，而多个 tag 可能对应的是同一个镜像。下面通过例子为大家介绍 Docker 社区普遍使用的 tag 方案。
假设我们现在发布了一个镜像 myimage，版本为 v1.9.1。那么我们可以给镜像打上四个 tag：1.9.1、1.9、1 和 latest。
我们可以通过 docker tag 命令方便地给镜像打 tag。
docker tag myimage-v1.9.1 myimage:1
docker tag myimage-v1.9.1 myimage:1.9
docker tag myimage-v1.9.1 myimage:1.9.1
docker tag myimage-v1.9.1 myimage:latest
过了一段时间，我们发布了 v1.9.2。这时可以打上 1.9.2 的 tag，并将 1.9、1 和 latest 从 v1.9.1 移到 v1.9.2。
命令为：
docker tag myimage-v1.9.2 myimage:1
docker tag myimage-v1.9.2 myimage:1.9
docker tag myimage-v1.9.2 myimage:1.9.2
docker tag myimage-v1.9.2 myimage:latest
之后，v2.0.0 发布了。这时可以打上 2.0.0、2.0 和 2 的 tag，并将 latest 移到 v2.0.0。
命令为：
docker tag myimage-v2.0.0 myimage:2
docker tag myimage-v2.0.0 myimage:2.0
docker tag myimage-v2.0.0 myimage:2.0.0
docker tag myimage-v2.0.0 myimage:latest
这种 tag 方案使镜像的版本很直观，用户在选择非常灵活：
- myimage:1 始终指向 1 这个分支中最新的镜像。
- myimage:1.9 始终指向 1.9.x 中最新的镜像。
- myimage:latest 始终指向所有版本中最新的镜像。
- 如果想使用特定版本，可以选择 myimage:1.9.1、myimage:1.9.2 或 myimage:2.0.0。
Docker Hub 上很多 repository 都采用这种方案，所以大家一定要熟悉。
下一节讨论如何使用使用公共 Registry。
019 使用公共Registry-dockerhub
可以作为了解，无法访问网址
Docker仓库类似于代码仓库，它是Docker集中存放镜像文件的场所。仓库注册服务器存放着很多类镜像，每类镜像包括多个镜像文件，通过不同的标签（tag）来进行区分。
根据所存储的镜像公开分享与否，Docker仓库可以分为:
- 公开仓库（Public）
- 私有仓库（Private）
目前，最大的公开仓库是官方提供的Docker Hub，其中存放了数量庞大的镜像供用户下载。国内不少云服务提供商（如华为、阿里云等）也提供了仓库的本地源，可以提供稳定的国内访问。
当然，用户如果不希望公开分享自己的镜像文件，Docker也支持用户在本地网络内创建一个只能自己访问的私有仓库。当用户创建了自己的镜像之后就可以使用push命令将它上传到指定的公有或者私有仓库。这样用户下次在另外一台机器上使用该镜像时，只需要将其从仓库上pull下来就可以了。
保存和分发镜像的最直接方法就是使用 Docker Hub。
Docker Hub 是 Docker 公司维护的公共 Registry。用户可以将自己的镜像保存到 Docker Hub 免费的 repository 中。如果不希望别人访问自己的镜像，也可以购买私有 repository。
除了 Docker Hub，quay.io 是另一个公共 Registry，提供与 Docker Hub 类似的服务。
下面介绍如何用 Docker Hub 存取我们的镜像。
-
首先得在 Docker Hub 上注册一个账号。
-
在 Docker Host 上登录。
这里用的是我自己的账号，用户名为 dcr，输入密码后登录成功。
-
修改镜像的 repository 使之与 Docker Hub 账号匹配。
Docker Hub 为了区分不同用户的同名镜像，镜像的 registry 中要包含用户名，完整格式为：[username]/xxx:tag
我们通过
docker tag命令重命名镜像。
注：Docker 官方自己维护的镜像没有用户名，比如 httpd。
-
通过 docker push 将镜像上传到 Docker Hub。
Docker 会上传镜像的每一层。因为 dcr/httpd:v1 这个镜像实际上跟官方的 httpd 镜像一模一样，Docker Hub 上已经有了全部的镜像层，所以真正上传的数据很少。同样的，如果我们的镜像是基于 base 镜像的，也只有新增加的镜像层会被上传。如果想上传同一 repository 中所有镜像，省略 tag 部分就可以了，例如：
docker push dcr/httpd
-
登录 https://hub.docker.com，在Public Repository 中就可以看到上传的镜像。
如果要删除上传的镜像，只能在 Docker Hub 界面上操作。
-
这个镜像可被其他 Docker host 下载使用了。
使用公共Registry-华为云
登录华为云
选择区域，选择离自己近的数据中心，创建组织
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
进入新创建的组织
接下来登录华为云，上传自己的镜像，复制登录指令
通过上面获取的登录指令，回到docker上登陆
bash
[root@docker ~]# docker login -u cn-east-3@HST3WWYX0IJ4KYMKJYOP -p 5cdefce4ea7aaeeae5a8cadadff126ddd422a61494474b82d57c1b649fb75c9d swr.cn-east-3.myhuaweicloud.com
WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded上传镜像
bash#命令格式 sudo docker tag {镜像名称}:{版本名称} swr.cn-east-3.myhuaweicloud.com/{组织名称}/{镜像名称}:{版本名称} sudo docker push swr.cn-east-3.myhuaweicloud.com/{组织名称}/{镜像名称}:{版本名称}
bash
#刚才Dockerfile制作的httpd:centos镜像 用来上传
[root@docker ~]# docker images httpd:centos
REPOSITORY TAG IMAGE ID CREATED SIZE
httpd centos 973cac3a687f 4 hours ago 288MB
#修改镜像名
[root@docker ~]# docker tag httpd:centos swr.cn-east-3.myhuaweicloud.com/dcr/centos_httpd:v1
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
httpd centos 973cac3a687f 4 hours ago 288MB
swr.cn-east-3.myhuaweicloud.com/dcr/centos_httpd v1 973cac3a687f 4 hours ago 288MB
#上传镜像
[root@docker ~]# docker push swr.cn-east-3.myhuaweicloud.com/dcr/centos_httpd:v1
The push refers to repository [swr.cn-east-3.myhuaweicloud.com/dcr/centos_httpd]
0ed52333a82d: Pushed
3ecb2dcd5414: Pushed
1b73832a4868: Pushed
5dc0365682c6: Pushed
5f70bf18a086: Layer already exists
de88e4999fda: Pushed
70a290c5e58b: Pushed
v1: digest: sha256:42dbc33f7e51ace426b90dd12dbf71b285ddc4d7f36c056cfb032c287f90609e size: 1779上传成功登录华为云查看：
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
下载自己上传的镜像
本地先把镜像删除再下载
bash
[root@docker ~]# docker rmi swr.cn-east-3.myhuaweicloud.com/dcr/centos_httpd:v1
复制pull命令
bash
[root@docker ~]# docker pull swr.cn-east-3.myhuaweicloud.com/dcr/centos_httpd:v1
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
swr.cn-east-3.myhuaweicloud.com/dcr/centos_httpd v1 973cac3a687f 4 hours ago 288MB设置为公开
点击右上角**...**
020 搭建本地Registry
Docker Hub 虽然非常方便，但还是有些限制，比如：
-
需要 internet 连接，而且下载和上传速度慢。
-
上传到 Docker Hub 的镜像任何人都能够访问，虽然可以用私有 repository，但不是免费的。
-
安全原因很多组织不允许将镜像放到外网。
解决方案就是搭建本地的 Registry。
Registry
Docker 已经将 Registry 开源了，同时在 Docker Hub 上也有官方的镜像 registry。下面我们就在 Docker 中运行自己的 registry。
-
启动 registry 容器。
shell[root@docker ~]# docker run -d -p 5000:5000 -v /myregistry:/var/lib/registry registry:2 Unable to find image 'registry:2' locally 2: Pulling from library/registry 1cc3d825d8b2: Pull complete 85ab09421e5a: Pull complete 40960af72c1c: Pull complete e7bb1dbb377e: Pull complete a538cc9b1ae3: Pull complete Digest: sha256:ac0192b549007e22998eb74e8d8488dcfe70f1489520c3b144a6047ac5efbe90 Status: Downloaded newer image for registry:2 a8214201171f28a13803c647ef84acdc982465c230cb5c6a034bd05574948408 [root@docker ~]#我们使用的镜像是 registry:2。
-d是后台启动容器。-p将容器的 5000 端口映射到 Host 的 5000 端口。5000 是 registry 服务端口。端口映射我们会在容器网络章节详细讨论。-v将容器 /var/lib/registry 目录映射到 Host 的 /myregistry，用于存放镜像数据。-v的使用我们会在容器存储章节详细讨论。 -
通过
docker tag重命名镜像，使之与 registry 匹配。shell[root@docker ~]# docker images REPOSITORY TAG IMAGE ID CREATED SIZE httpd latest 5daf6a4bfe74 2 months ago 148MB [root@docker ~]# docker tag httpd:latest localhost:5000/httpd:v1 [root@docker ~]# docker images REPOSITORY TAG IMAGE ID CREATED SIZE httpd latest 5daf6a4bfe74 2 months ago 148MB localhost:5000/httpd v1 5daf6a4bfe74 2 months ago 148MB我们在镜像的前面加上了运行 registry 的主机名称和端口。
前面已经讨论了镜像名称由 repository 和 tag 两部分组成。而 repository 的完整格式为**：[registry-host]:[port]/[username]/xxx**
只有 Docker Hub 上的镜像可以省略 [registry-host]:[port] 。
-
通过
docker push上传镜像。shell[root@docker ~]# docker push localhost:5000/httpd:v1 The push refers to repository [localhost:5000/httpd] 85d0eb049481: Pushed 53a350bcb78a: Pushed db9328cd0153: Pushed 5f70bf18a086: Pushed 3bbc250aae52: Pushed 8d853c8add5d: Pushed v1: digest: sha256:f432c26db81bdb6eb2c60c61d5d607615398f2e983eaaaff87ade6bbb2fec875 size: 1572 [root@docker httpd]# curl http://localhost:5000/v2/_catalog {"repositories":["httpd"]} -
现在已经可通过
docker pull从本地 registry 下载镜像了。shell#下载之前先删除本地的镜像 [root@docker ~]# docker rmi httpd:latest [root@docker ~]# docker rmi localhost:5000/httpd:v1 #从自建仓库下载镜像 [root@docker ~]# docker pull localhost:5000/httpd:v1 v1: Pulling from httpd 302e3ee49805: Already exists 4669bea11670: Pull complete 4f4fb700ef54: Pull complete ca8887d72588: Pull complete c7c900975bf7: Pull complete 95eac36196b2: Pull complete Digest: sha256:f432c26db81bdb6eb2c60c61d5d607615398f2e983eaaaff87ade6bbb2fec875 #验证从自建仓库下载的镜像 [root@docker ~]# docker images localhost:5000/httpd REPOSITORY TAG IMAGE ID CREATED SIZE localhost:5000/httpd v1 5daf6a4bfe74 2 months ago 148MB除了镜像的名称长一些（包含 registry host 和 port)，使用方式完全一样。
以上是搭建本地 registry 的简要步骤。当然 registry 也支持认证，https 安全传输等特性，具体可以参考官方文档 https://docs.docker.com/registry/configuration/
企业级私有仓库Harbor
我们如果需要部署一个私有镜像仓库来使用，最简单的就是 registry ，一行命令就可以运行在 Docker 中，但功能也比较弱，如果想要私有镜像仓库功能更丰富些，可以使用 Harbor。
本文简单介绍下 Harbor 的安装和使用。
Harbor是构建企业级私有docker镜像的仓库的开源解决方案，它是Docker Registry的更高级封装，除了提供友好的Web UI界面，角色和用户权限管理，用户操作审计等功能外，它还整合了K8s的插件(Add-ons)仓库。
harbor下载：https://github.com/goharbor/harbor/releases
安装
bash
[root@docker ~]# wget https://github.com/goharbor/harbor/releases/download/v2.9.1/harbor-offline-installer-v2.9.1.tgz如果无法通过 wget 进行下载，可以直接到 Github 网站：https://github.com/goharbor/harbor/releases/ 进行下载，然后拷贝到服务器中
bash
[root@docker ~]# ls
harbor-offline-installer-v2.9.1.tgz执行下面命令进行解压
bash
[root@docker ~]# tar -xvf harbor-offline-installer-v2.9.1.tgz
harbor/harbor.v2.9.1.tar.gz
harbor/prepare
harbor/LICENSE
harbor/install.sh
harbor/common.sh
harbor/harbor.yml.tmpl执行下面命令新建目录，并将程序文件复制到目录中：
bash
[root@docker ~]# mkdir /opt/harbor
[root@docker ~]# mv harbor/* /opt/harbor/导入Harbor镜像
bash
[root@docker ~]# cd /opt/harbor/
[root@docker harbor]# docker load -i harbor.v2.9.1.tar.gz 修改 Harbor 配置文件
bash
[root@docker ~]# cd /opt/harbor/
[root@docker harbor]# cp -ar harbor.yml.tmpl harbor.yml
[root@docker harbor]# vim harbor.yml
**hostname：**如果只是内网访问，设置为内网 IP，如果需要外网访问，就必须设置为外网域名或 IP
https: #注释掉
harbor_admin_password: harbor登录密码
编辑完配置文件，接下来在 harbor 目录下安装 Harbor。先进行预处理更新配置文件
bash
[root@docker harbor]# ./prepare
prepare base dir is set to /opt/harbor
WARNING:root:WARNING: HTTP protocol is insecure. Harbor will deprecate http protocol in the future. Please make sure to upgrade to https
Generated configuration file: /config/portal/nginx.conf
Generated configuration file: /config/log/logrotate.conf
Generated configuration file: /config/log/rsyslog_docker.conf
Generated configuration file: /config/nginx/nginx.conf
Generated configuration file: /config/core/env
Generated configuration file: /config/core/app.conf
Generated configuration file: /config/registry/config.yml
Generated configuration file: /config/registryctl/env
Generated configuration file: /config/registryctl/config.yml
Generated configuration file: /config/db/env
Generated configuration file: /config/jobservice/env
Generated configuration file: /config/jobservice/config.yml
Generated and saved secret to file: /data/secret/keys/secretkey
Successfully called func: create_root_cert
Generated configuration file: /compose_location/docker-compose.yml
Clean up the input dir执行下面命令进行安装
bash
[root@docker harbor]# ./install.sh
[Step 0]: checking if docker is installed ...
Note: docker version: 26.1.3
[Step 1]: checking docker-compose is installed ...
Note: Docker Compose version v2.27.0
[Step 2]: loading Harbor images ...
Loaded image: goharbor/harbor-jobservice:v2.9.1
Loaded image: goharbor/harbor-registryctl:v2.9.1
Loaded image: goharbor/harbor-core:v2.9.1
Loaded image: goharbor/harbor-log:v2.9.1
Loaded image: goharbor/harbor-db:v2.9.1
Loaded image: goharbor/harbor-exporter:v2.9.1
Loaded image: goharbor/redis-photon:v2.9.1
Loaded image: goharbor/nginx-photon:v2.9.1
Loaded image: goharbor/registry-photon:v2.9.1
Loaded image: goharbor/trivy-adapter-photon:v2.9.1
Loaded image: goharbor/prepare:v2.9.1
Loaded image: goharbor/harbor-portal:v2.9.1
[Step 3]: preparing environment ...
[Step 4]: preparing harbor configs ...
prepare base dir is set to /opt/harbor
WARNING:root:WARNING: HTTP protocol is insecure. Harbor will deprecate http protocol in the future. Please make sure to upgrade to https
Clearing the configuration file: /config/portal/nginx.conf
Clearing the configuration file: /config/log/logrotate.conf
Clearing the configuration file: /config/log/rsyslog_docker.conf
Clearing the configuration file: /config/nginx/nginx.conf
Clearing the configuration file: /config/core/env
Clearing the configuration file: /config/core/app.conf
Clearing the configuration file: /config/registry/passwd
Clearing the configuration file: /config/registry/config.yml
Clearing the configuration file: /config/registryctl/env
Clearing the configuration file: /config/registryctl/config.yml
Clearing the configuration file: /config/db/env
Clearing the configuration file: /config/jobservice/env
Clearing the configuration file: /config/jobservice/config.yml
Generated configuration file: /config/portal/nginx.conf
Generated configuration file: /config/log/logrotate.conf
Generated configuration file: /config/log/rsyslog_docker.conf
Generated configuration file: /config/nginx/nginx.conf
Generated configuration file: /config/core/env
Generated configuration file: /config/core/app.conf
Generated configuration file: /config/registry/config.yml
Generated configuration file: /config/registryctl/env
Generated configuration file: /config/registryctl/config.yml
Generated configuration file: /config/db/env
Generated configuration file: /config/jobservice/env
Generated configuration file: /config/jobservice/config.yml
loaded secret from file: /data/secret/keys/secretkey
Generated configuration file: /compose_location/docker-compose.yml
Clean up the input dir
Note: stopping existing Harbor instance ...
WARN[0000] /opt/harbor/docker-compose.yml: `version` is obsolete
[Step 5]: starting Harbor ...
WARN[0000] /opt/harbor/docker-compose.yml: `version` is obsolete
[+] Running 10/10
✔ Network harbor_harbor Created 0.2s
✔ Container harbor-log Started 1.1s
✔ Container registry Started 3.2s
✔ Container redis Started 3.4s
✔ Container harbor-db Started 3.4s
✔ Container registryctl Started 3.2s
✔ Container harbor-portal Started 3.0s
✔ Container harbor-core Started 4.2s
✔ Container harbor-jobservice Started 5.3s
✔ Container nginx Started 5.1s
✔ ----Harbor has been installed and started successfully.----稍等一会,如果所有容器的状态都是 healthy ，说明正常
登录WEB界面：http://192.168.108.30
使用
Harbor 里功能比较多，常用的有项目、用户管理、项目定额。
- 项目：可以针对不同的项目单独创建，每个项目都有自己的镜像地址
- 用户管理：可以维护用户，不同的项目可以设置不同的维护人员
- 项目定额：设置项目对应的镜像仓库最大空间容量
下面就按照步骤将一个镜像推送到 Harbor 中。
1、在用户管理中创建名称为 images_admin 的用户：
在项目中创建名称为cloud的项目，并添加 images_admin 为项目管理员
将内网服务器 IP 和端口配置到 daemon.json 文件中，执行下面命令进行配置
bash
[root@docker ~]# vim /etc/docker/daemon.json
{
"insecure-registries": ["192.168.108.30"],
"registry-mirrors": [ "https://054b8ac70e8010d90f2ac00ef29e6580.mirror.swr.myhuaweicloud.com" ]
}
[root@docker ~]# systemctl restart docker
#重新执行安装命令
[root@docker harbor]# ./install.sh登录服务器
bash
[root@docker ~]# docker login 192.168.108.30
Username: images_admin
Password:Cloud12#$
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded登录后家目录下会有一个.docker文件夹
bash
[root@docker ~]# cd ~/.docker/
[root@docker .docker]# pwd
/root/.docker
[root@docker .docker]# cat config.json
{
"auths": {
"192.168.108.30": {
"auth": "aW1hZ2VzX2FkbWluOkNsb3VkMTIjJA=="
},
"swr.cn-north-4.myhuaweicloud.com": {
"auth": "Y24tbm9ydGgtNEBMUVhBVjU4MENES1A3SUoxTDREMzpmM2NlMTJlODY4ODVkN2JkZWZlYmFiMWI1N2RmZDBiYjJiM2MxZTEyNjUxYWQ1ZTk1ODY1Nzg4MTczYzI4OTJj"
}
}
}上传镜像
bash
[root@docker .docker]# docker tag nginx:latest 192.168.108.30/cloud/nginx:latest
[root@docker .docker]# docker push 192.168.108.30/cloud/nginx:latest
The push refers to repository [192.168.108.30/cloud/nginx]
11de3d47036d: Pushed
16907864a2d0: Pushed
2bdf51597158: Pushed
0fc6bb94eec5: Pushed
eda13eb24d4c: Pushed
67796e30ff04: Pushed
8e2ab394fabf: Pushed
latest: digest: sha256:596c783ac62b9a43c60edb876fe807376cd5022a4e25e89b9a9ae06c374299d4 size: 1778镜像格式：SERVER/PROJECT /PATH/TO/IMAGE/IMAGE:TAG
下载镜像
bash
[root@docker .docker]# docker pull 192.168.108.30/cloud/nginx
Using default tag: latest
latest: Pulling from cloud/nginx
a2318d6c47ec: Pull complete
095d327c79ae: Pull complete
bbfaa25db775: Pull complete
7bb6fb0cfb2b: Pull complete
0723edc10c17: Pull complete
24b3fdc4d1e3: Pull complete
3122471704d5: Pull complete
Digest: sha256:596c783ac62b9a43c60edb876fe807376cd5022a4e25e89b9a9ae06c374299d4
Status: Downloaded newer image for 192.168.108.30/cloud/nginx:latest
192.168.108.30/cloud/nginx:latest卸载harbor
清理容器
bash
[root@docker ~]# cd /opt/harbor/
[root@docker harbor]# docker compose down
WARN[0000] /opt/harbor/docker-compose.yml: `version` is obsolete
[+] Running 10/10
✔ Container nginx Removed 0.5s
✔ Container registryctl Removed 0.5s
✔ Container harbor-jobservice Removed 0.0s
✔ Container harbor-core Removed 0.4s
✔ Container harbor-portal Removed 0.4s
✔ Container redis Removed 0.5s
✔ Container registry Removed 0.4s
✔ Container harbor-db Removed 0.5s
✔ Container harbor-log Removed 10.5s
✔ Network harbor_harbor Removed 清理镜像
bash
[root@docker harbor]# docker images |grep harbor|awk '{print $1":"$2}' | xargs docker rmi清理harbor使用的目录/data，由prepare脚本定义
bash
[root@docker harbor]# rm -rf /data删除软件包
bash
[root@docker opt]# cd
[root@docker ~]# ls
anaconda-ks.cfg harbor harbor-offline-installer-v2.9.1.tgz
[root@docker ~]# rm -f harbor-offline-installer-v2.9.1.tgz
[root@docker ~]# rm -rf /opt/harbor/至此，Docker 镜像的内容就讨论完了，下节我们对这部分做个小结。
021 Docker镜像小结
本节我们对 Docker 镜像做个小结。
这一部分我们首先讨论了镜像的分层结构，然后学习了如何构建镜像，最后实践使用 Docker Hub 和本地 registry。
下面是镜像的常用操作子命令：
images 显示镜像列表
history 显示镜像构建历史
commit 从容器创建新镜像
build 从 Dockerfile 构建镜像
tag 给镜像打 tag
pull 从 registry 下载镜像
push 将 镜像 上传到 registry
rmi 删除 Docker host 中的镜像
search 搜索 Docker Hub 中的镜像
除了 rmi 和 search，其他命令都已经用过了。
rmi
rmi 只能删除 host 上的镜像，不会删除 registry 的镜像。
如果一个镜像对应了多个 tag，只有当最后一个 tag 被删除时，镜像才被真正删除。例如 host 中 busybox镜像有三个 tag：
shell
[root@docker ~]# docker images busybox
REPOSITORY TAG IMAGE ID CREATED SIZE
busybox latest 6fd955f66c23 16 months ago 4.26MB
[root@docker ~]# docker tag busybox:latest busybox:v1
[root@docker ~]# docker tag busybox:latest busybox:v2
[root@docker ~]# docker images busybox
REPOSITORY TAG IMAGE ID CREATED SIZE
busybox latest 6fd955f66c23 16 months ago 4.26MB
busybox v1 6fd955f66c23 16 months ago 4.26MB
busybox v2 6fd955f66c23 16 months ago 4.26MB删除其中 busybox:latest 只是删除了 latest tag，镜像本身没有删除。
只有当 busybox:v1 和busybox:v2也被删除时，整个镜像才会被删除。
search
search 让我们无需打开浏览器，在命令行中就可以搜索 Docker Hub 中的镜像。
当然，如果想知道镜像都有哪些 tag，还是得访问 Docker Hub。
保存本地镜像为文件-save
docker默认使用overlay2存储驱动存储镜像。
bash
[root@docker ~]# docker info | grep 'Storage Driver'
Storage Driver: overlay2镜像存储在本地/var/lib/docker/overlay2，通过文件系统层面拷贝image，操作复杂。可以使用save命令，将本地镜像保存为单个文件，并分享给他人使用。
bash
[root@docker ~]# docker save --help
Usage: docker save [OPTIONS] IMAGE [IMAGE...]
Save one or more images to a tar archive (streamed to STDOUT by default)
Aliases:
docker image save, docker save
Options:
-o, --output string Write to a file, instead of STDOUT示例：
bash
[root@docker ~]# docker save httpd -o httpd.tar #httpd是镜像名 httpd.tar是要保存的文件名
[root@docker ~]# docker save httpd hello-world -o images.tar #将httpd,hello-world镜像保存为images.tar
[root@docker ~]# ls
httpd.tar images.tar将本地镜像文件导入本地-load
bash
[root@docker ~]# docker load --help
Usage: docker load [OPTIONS]
Load an image from a tar archive or STDIN
Aliases:
docker image load, docker load
Options:
-i, --input string Read from tar archive file, instead of STDIN
-q, --quiet Suppress the load output示例：删除本地镜像，并导入本地镜像文件
bash
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
httpd latest 90f191b9781e 11 days ago 148MB
hello-world latest 74cc54e27dc4 6 months ago 10.1kB
[root@docker ~]# docker rmi httpd:latest hello-world:latest
Untagged: httpd:latest
Untagged: httpd@sha256:f84fe51ff5d35124e024f51215b443b16c939b24eae747025a515200e71c7d07
Deleted: sha256:90f191b9781e01f5cd601af7b32d4ebb46770d1a98fa9170c328f9a78458b758
Deleted: sha256:8cbdaf91f3d9b2916bd85a36c608c8b652176b92266a6c51ead6c52f487b9eb5
Deleted: sha256:352b0ea3b9e318a2111200ed85540548a23873ce5ab5e6076b1dcef0110724ce
Deleted: sha256:7810a27010681e9307dae49c3673a021928add80b99e43937d79a3c5322cb862
Deleted: sha256:3c75e1b632ae15a9a14d7527fb134de5d45b2abcf3eef1cfaa057d702b957dba
Deleted: sha256:4eabd365f7baf2356d8d27adb4a182e45fca9dfc1d5533e93832c243135a5aa9
Deleted: sha256:1bb35e8b4de116e84b2ccf614cce4e309b6043bf2cd35543d8394edeaeb587e3
Untagged: hello-world:latest
Untagged: hello-world@sha256:ec153840d1e635ac434fab5e377081f17e0e15afab27beb3f726c3265039cfff
Deleted: sha256:74cc54e27dc41bb10dc4b2226072d469509f2f22f1a3ce74f4a59661a1d44602
Deleted: sha256:63a41026379f4391a306242eb0b9f26dc3550d863b7fdbb97d899f6eb89efe72
[root@docker ~]# docker images #本地没有镜像
REPOSITORY TAG IMAGE ID CREATED SIZE删除本地正在使用的镜像需要选项-f
导入镜像
bash
[root@docker ~]# docker load -i images.tar
1bb35e8b4de1: Loading layer 77.88MB/77.88MB
6c5ea8a96778: Loading layer 2.56kB/2.56kB
5f70bf18a086: Loading layer 1.024kB/1.024kB
785236f38f5b: Loading layer 11.41MB/11.41MB
5ca968893b91: Loading layer 62.99MB/62.99MB
b4558c4e936a: Loading layer 3.584kB/3.584kB
Loaded image: httpd:latest
63a41026379f: Loading layer 11.78kB/11.78kB
Loaded image: hello-world:latest
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
httpd latest 90f191b9781e 11 days ago 148MB
hello-world latest 74cc54e27dc4 6 months ago 10.1kB说明：如果本地镜像名与导入的镜像重名，则本地的镜像会被覆盖。
bash[root@docker ~]# docker rm -f $(docker ps -aq) #删除所有容器 [root@docker ~]# docker rmi -f $(docker images -aq) #删除所有镜像
至此，Docker 镜像已经讨论完了，下节我们深入讨论容器。
第4章 容器
022 如何运行容器？
上一章我们学习了如何构建 Docker 镜像，并通过镜像运行容器。本章将深入讨论容器：学习容器的各种操作，容器各种状态之间如何转换，以及实现容器的底层技术。
运行容器
docker run=docker create + docker start
docker run 是启动容器的方法。在讨论 Dockerfile 时我们已经学习到，可用三种方式指定容器启动时执行的命令：
- CMD 指令。
- ENTRYPOINT 指令。
- 在
docker run命令行中指定。
例如下面的例子：
bash
[root@docker ~]# docker create ubuntu #使用ubuntu镜像创建容器
eb1aa0ca86b2d49250ebe64913af50e88482ad68b9c3e61ef8f8da9c24b00f7a #新创建的容器长ID
[root@docker ~]# docker ps -a #create的容器状态时Cre'a'te'd
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
eb1aa0ca86b2 ubuntu "/bin/bash" 2 seconds ago `Created` quizzical_goldwasser
[root@docker ~]# docker start eb1aa0ca86b2 #启动容器，刚创建的容器ID
eb1aa0ca86b2
[root@docker ~]# docker ps -a #查看容器状态，启动了又退出了
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
eb1aa0ca86b2 ubuntu "/bin/bash" 23 seconds ago Exited (0) 3 seconds ago quizzical_goldwasser
shell
[root@docker ~]# docker run ubuntu pwd #使用ubuntu镜像创建容器并执行pwd命令
/
[root@docker ~]#容器启动时执行 pwd，返回的 / 是容器中的当前目录。 执行 docker ps 或 docker container ls 可以查看 Docker host 中当前运行的容器：
bash
[root@docker ~]# docker ps #查看所有正在运行中的容器
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES咦，怎么没有容器？用 docker ps -a 或 docker container ls -a 看看。
-a 会显示所有状态的容器，可以看到，之前的容器已经退出了，状态为Exited。
这种"一闪而过"的容器通常不是我们想要的结果，我们希望容器能够保持 runing 状态，这样才能被我们使用。
让容器长期运行
如何让容器保存运行呢？
因为容器的生命周期依赖于启动时执行的命令，只要该命令不结束，容器也就不会退出。
理解了这个原理，我们就可以通过执行一个长期运行的命令来保持容器的运行状态。例如执行下面的命令：
bash
[root@docker ~]# docker run ubuntu /bin/bash -c "while true ; do sleep 1 ; echo hahaha; done"while 语句让 bash 不会退出。我们可以打开另一个终端查看容器的状态：
可见容器仍处于运行状态。不过这种方法有个缺点：它占用了一个终端。
我们可以加上参数 -d 以后台方式启动容器。
bash
[root@docker ~]# docker run -d ubuntu /bin/bash -c "while true ; do sleep 1 ; echo hahaha; done"
2a0bfa267fe146753b4fc8b23d55b08fbe3a5f9b5e093de6885133f6bbd20c56
[root@docker ~]#容器启动后回到了 docker host 的终端。这里看到 docker 返回了一串字符，这是容器的 ID。通过 docker ps 查看容器：
现在我们有了两个正在运行的容器。这里注意一下容器的 CONTAINER ID和 NAMES 这两个字段。
CONTAINER ID 是容器的 "短ID"，前面启动容器时返回的是 "长ID"。短ID是长ID的前12个字符。
NAMES 字段显示容器的名字，在启动容器时可以通过 --name 参数显示地为容器命名，如果不指定，docker 会自动为容器分配名字。
对于容器的后续操作，我们需要通过 "长ID"、"短ID" 或者 "名称" 来指定要操作的容器。比如下面停止一个容器：
bash
[root@docker ~]# docker stop 081be2bc2e1d
081be2bc2e1d这里我们就是通过 "短ID" 指定了要停止的容器。
通过 while 启动的容器虽然能够保持运行，但实际上没有干什么有意义的事情。容器常见的用途是运行后台服务，例如前面我们已经看到的 http server：
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
这一次我们用 --name 指定了容器的名字。 我们还看到容器运行的命令是httpd-foreground，通过 docker history 可知这个命令是通过 CMD 指定的。
我们经常需要进到容器里去做一些工作，比如查看日志、调试、启动其他进程等。下一节学习如何进入容器内部。
023 两种进入容器的方法
我们经常需要进到容器里去做一些工作，比如查看日志、调试、启动其他进程等。有两种方法进入容器：attach 和 exec。
docker attach
通过 docker attach 可以 attach 到容器启动命令的终端，例如：
bash
[root@docker ~]# docker run -d ubuntu /bin/bash -c "while true ; do sleep 1 ; echo I_am_in_container ; done"
dc508b94447f83b46080267580607569a187fcc7f780433f646e9d66949731a6
[root@docker ~]#
[root@docker ~]# docker attach dc508b94447f83b46080267580607569a187fcc7f780433f646e9d66949731a6
I_am_in_container
I_am_in_container
I_am_in_container
I_am_in_container这次我们通过 "长ID" attach 到了容器的启动命令终端，之后看到的是echo 每隔一秒打印的信息。
注：可通过 Ctrl+p 然后 Ctrl+q 组合键退出 attach 终端。（快捷键冲突，需要再按shift）
docker exec
通过 docker exec 进入相同的容器：
说明如下：
① -it 以交互模式打开 pseudo-TTY，执行 bash，其结果就是打开了一个 bash 终端。
② 进入到容器中，容器的 hostname 就是其 "短ID"。
③ 可以像在普通 Linux 中一样执行命令。ps -elf 显示了容器启动进程while 以及当前的 bash 进程。
④ 执行 exit 退出容器，回到 docker host。
docker exec -it <container> bash|sh 是执行 exec 最常用的方式。
attach VS exec
attach 与 exec 主要区别如下:
- attach 直接进入容器 启动命令 的终端，不会启动新的进程。
- exec 则是在容器中打开新的终端，并且可以启动新的进程。
- 如果想直接在终端中查看启动命令的输出，用 attach；其他情况使用 exec。
当然，如果只是为了查看启动命令的输出，可以使用 docker logs 命令：
bash
[root@docker ~]# docker logs -f dc508b94447f
I_am_in_container
I_am_in_container
I_am_in_container
I_am_in_container
I_am_in_container
I_am_in_container
I_am_in_container-f 的作用与 tail -f 类似，能够持续打印输出。
下一节聊聊运行容器的最佳实践。
024 运行容器的最佳实践
按用途容器大致可分为两类：服务类容器和工具类的容器。
- 服务类容器以 daemon 的形式运行，对外提供服务。比如 web server，数据库等。通过
-d以后台方式启动这类容器是非常合适的。如果要排查问题，可以通过exec -it进入容器。 - 工具类容器通常给能我们提供一个临时的工作环境，通常以
run -it方式运行，比如：
bash
[root@docker ~]# docker run -it busybox
/ #
/ # wget www.baidu.com
Connecting to www.baidu.com (223.109.82.6:80)
saving to 'index.html'
index.html 100% |********************| 2381 0:00:00 ETA
'index.html' saved
/ #
/ # exit
[root@docker ~]#运行 busybox，run -it 的作用是在容器启动后就直接进入。我们这里通过 wget 验证了在容器中访问 internet 的能力。执行 exit 退出终端，同时容器停止。
工具类容器多使用基础镜像，例如 busybox、debian、ubuntu 等。
容器运行小结
容器运行相关的知识点：
- 当 CMD 或 Entrypoint 或 docker run 命令行指定的命令运行结束时，容器停止。
- 通过
-d参数在后台启动容器。 - 通过
exec -it可进入容器并执行命令。
指定容器的三种方法：
- 短ID。
- 长ID。
- 容器名称。 可通过
--name为容器命名。重命名容器可执行docker rename。
容器按用途可分为两类：
- 服务类的容器。
- 工具类的容器。
下一节讨论容器的其他操作，比如 stop, restart, pause, delete。
025 容器常用操作
前面讨论了如何运行容器，本节学习容器的其他常用操作。
stop/start/restart 容器
通过 docker stop 可以停止运行的容器。
容器在 docker host 中实际上是一个进程，docker stop 命令本质上是向该进程发送一个 SIGTERM 信号。如果想快速停止容器，可使用 docker kill 命令，其作用是向容器进程发送 SIGKILL 信号。
对于处于停止状态的容器，可以通过 docker start 重新启动。
docker start 会保留容器的第一次启动时的所有参数。
docker restart 可以重启容器，其作用就是依次执行 docker stop 和docker start。
容器可能会因某种错误而停止运行。对于服务类容器，我们通常希望在这种情况下容器能够自动重启。启动容器时设置 --restart 就可以达到这个效果。
如果docker run -d httpd不加--restart=always参数，attach进去ctrl_c（终止进程）不会重启。
--restart=always 意味着无论容器因何种原因退出（包括正常退出），就立即重启。该参数的形式还可以是 --restart=on-failure:3，意思是如果启动进程退出代码非0，则重启容器，最多重启3次。
pause/unpause 容器
有时我们只是希望暂时让容器暂停工作一段时间，比如要对容器的文件系统打个快照，或者 dcoker host 需要使用 CPU，这时可以执行 docker pause。
处于暂停状态的容器不会占用 CPU 资源，直到通过 docker unpause 恢复运行。
删除容器
使用 docker 一段时间后，host 上可能会有大量已经退出了的容器。
这些容器依然会占用 host 的文件系统资源，如果确认不会再重启此类容器，可以通过 docker rm 删除。
bash
[root@docker ~]# docker rm 35af7150bd17 9769bb915803
35af7150bd17
9769bb915803docker rm 一次可以指定多个容器，如果希望批量删除所有已经退出的容器，可以执行如下命令：
docker rm -v $(docker ps -aq -f status=exited)
bash
# !!!慎用,删除所有状态容器
[root@docker ~]# docker rm -f $(docker ps -aq)顺便说一句：docker rm 是删除容器，而 docker rmi 是删除镜像。
一下学了这么多操作，很有必要做个总结。下一节我们会用一张图来描述容器的状态机。
026 一张图搞懂容器所有操作
前面我们已经讨论了容器的各种操作，对容器的生命周期有了大致的理解，下面这张状态机很好地总结了容器各种状态之间是如何转换的。
如果掌握了前面的知识，要看懂这张图应该不难。不过有两点还是需要补充一下：
-
可以先创建容器，稍后再启动。
①
docker create创建的容器处于 Created 状态。②
docker start将以后台方式启动容器。docker run命令实际上是docker create和docker start的组合。 -
只有当容器的启动进程 退出 时，
--restart才生效。
退出包括正常退出或者非正常退出。这里举了两个例子：启动进程正常退出或发生 OOM，此时 docker 会根据
--restart的策略判断是否需要重启容器。但如果容器是因为执行docker stop或docker kill退出，则不会自动重启。
bash
[root@docker ~ 15:54:39]# docker run -d --restart=always httpd
3c7ce53170b9f3a834ee882a783f133b54d38743382b1fadc2e7fa47b6c5dfbd #设置为重启状态，即发生退出即刻重启
[root@docker ~ 15:55:21]# docker attach 3c #进入启动命令的终端 ctrl c 结束进程
^C[Mon Nov 17 07:55:44.278661 2025] [mpm_event:notice] [pid 1:tid 1] AH00491: caught SIGTERM, shutting down
[root@docker ~ 15:55:44]# docker ps #发现容器已经重启
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3c7ce53170b9 httpd "httpd-foreground" 36 seconds ago Up 11 seconds 80/tcp priceless_blackburn
[root@docker ~ 15:55:56]# docker stop 3c #利用stop 停止容器
3c
[root@docker ~ 15:56:31]# docker ps -a #发现容器无法自动重启
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3c7ce53170b9 httpd "httpd-foreground" About a minute ago Exited (0) 6 seconds ago priceless_blackburn
[root@docker ~ 15:56:36]# docker restart 3c #重启容器
3c
[root@docker ~ 15:56:58]# docker kill 3c #利用kill 杀死进程
3c
[root@docker ~ 15:57:08]# docker ps -a #发现容器无法自动重启
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
3c7ce53170b9 httpd "httpd-foreground" About a minute ago Exited (137) 4 seconds ago priceless_blackburn好了，容器操作就讨论到这里，下一节我们将学习如何限制容器对资源的使用。
027 限制容器对内存的使用
cgroup简介
docker 通过 cgroup 来控制容器使用的资源配额，包括 CPU、内存、磁盘三大方面，基本覆盖了常见的资源配额和使用量控制。
cgroup 是 Control Groups 的缩写，是 Linux 内核提供的一种可以限制、记录、隔离进程组所使用的物理资源(如 cpu、memory、磁盘IO等等) 的机制，被 LXC、docker 等很多项目用于实现进程资源控制。cgroup 将任意进程进行分组化管理的 Linux 内核功能。cgroup 本身是提供将进程进行分组化管理的功能和接口的基础结构，I/O 或内存的分配控制等具体的资源管理功能是通过这个功能来实现的。这些具体的资源管理功能称为 cgroup 子系统，有以下几大子系统实现：
blkio：设置限制每个块设备的输入输出控制。例如:磁盘，光盘以及 usb 等等。
cpu：使用调度程序为 cgroup 任务提供 cpu 的访问。
cpuacct：产生 cgroup 任务的 cpu 资源报告。
cpuset：如果是多核心的 cpu，这个子系统会为 cgroup 任务分配单独的 cpu 和内存。
devices：允许或拒绝 cgroup 任务对设备的访问。
freezer：暂停和恢复 cgroup 任务。
memory：设置每个 cgroup 的内存限制以及产生内存资源报告。
net_cls：标记每个网络包以供 cgroup 方便使用。
ns：命名空间子系统。
perf_event：增加了对每 group 的监测跟踪的能力，可以监测属于某个特定的 group 的所有线程以及运行在特定CPU上的线程。
stress是什么？
是模拟压力测试的工具
在机器上模拟cpu、内存等使用率
来检测不同状态下的运行情况
目前 docker 只是用了其中一部分子系统，实现对资源配额和使用的控制。
可以使用 stress 工具来测试 CPU 和内存。使用下面的 Dockerfile 来创建一个基于 Ubuntu 的 stress 工具镜像。
Dockerfile
dockerfile
[root@docker dockerfile]# vim Dockerfile
# Version 1
FROM ubuntu
MAINTAINER dcr "6946630@qq.com"
RUN apt-get -y update && apt-get -y install stress
ENTRYPOINT ["/usr/bin/stress"] # 以服务或进程的形式运行使用Dockerfile构建镜像ubuntu-with-stress
bash
[root@docker ~]# docker build -t ubuntu-with-stress .一个 docker host 上会运行若干容器，每个容器都需要 CPU、内存和 IO 资源。对于 KVM，VMware 等虚拟化技术，用户可以控制分配多少 CPU、内存资源给每个虚拟机。对于容器，Docker 也提供了类似的机制避免某个容器因占用太多资源而影响其他容器乃至整个 host 的性能。
内存限额
与操作系统类似，容器可使用的内存包括两部分：物理内存和 swap。 Docker 通过下面两组参数来控制容器内存的使用量。
-m或--memory：设置内存的使用限额，例如 100M, 2G。--memory-swap：设置 内存+swap 的使用限额。
当我们执行如下命令：
docker run -m 200M --memory-swap=300M ubuntu
其含义是允许该容器最多使用 200M 的内存和 100M 的 swap。
正常情况下，--memory-swap 的值包含容器可用内存和可用swap。所以 -m 300m --memory-swap=1g 的含义为：容器可用使用300M的物理内存，并且可以使用700M（1G-300）的swap。
如果--memory-swap 设置为0 或者不设置，则容器可以使用的swap大小为-m值的两倍。
如果 --memory-swap 的值和-m 值相同，则容器不能使用swap
如果 --memory-swap值为-1。它表示容器程序使用的内存受限，而可以使用的swap空间不受限制（宿主机有多少swap空间该容器就可以使用多少）
下面我们将使用ubuntu-with-stress镜像来学习如何为容器分配内存。该镜像可用于对容器执行压力测试。执行如下命令：
bash
[root@docker ~]# docker run -it -m 200M --memory-swap=300M ubuntu-with-stress --vm 1 --vm-bytes 280M -v--vm 1：启动 1 个内存工作线程。
--vm-bytes 280M：每个线程分配 280M 内存。
运行结果如下：
因为 280M 在可分配的范围（300M）内，所以工作线程能够正常工作，其过程是：
- 分配 280M 内存。
- 释放 280M 内存。
- 再分配 280M 内存。
- 再释放 280M 内存。
- 一直循环...
如果让工作线程分配的内存超过 300M，结果如下：
分配的内存超过限额，stress 线程报错，容器退出。
如果在启动容器时只指定 -m 而不指定 --memory-swap，那么 --memory-swap 默认为 -m 的两倍，比如：
docker run -it -m 200M ubuntu-with-stress
容器最多使用 200M 物理内存和 200M swap。
内存限额就讨论到这里，下一节我们学习如何限制容器对 CPU 资源的使用。
028 限制容器对CPU的使用
上节学习了如何限制容器对内存的使用，本节我们来看CPU。
默认设置下，所有容器可以平等地使用 host CPU 资源并且没有限制。
Docker 可以通过 -c 或 --cpu-shares 设置容器使用 CPU 的权重。如果不指定，默认值为 1024。
--cpu-shares的值不能保证可以获得1个 vcpu 或者多少 GHz 的 CPU 资源，仅仅只是一个弹性的加权值。
默认情况下，每个 docker 容器的 cpu 份额都是1024。单独一个容器的份额是没有意义的，只有在同时运行多个容器时，容器的 CPU 加权的效果才能体现出来。例如，两个容器A、B的 CPU 份额分别为1000和500，在 CPU 进行时间片分配的时候，容器 A 比容器 B 多一倍的机会获得 CPU 的时间片，但分配的结果取决于当时主机和其他容器的运行状态，实际上也无法保证容器A一定能获得 CPU 时间片。比如容器A的进程一直是空闲的，那么容器B是可以获取比容器A更多的 CPU 时间片的。极端情况下，比如说主机上只运行了一个容器，即使它的 CPU 份额只有 50，它也可以独占整个主机的 CPU 资源。
cgroups 只在容器分配的资源紧缺时，也就是说在需要对容器使用的资源进行限制时，才会生效。因此，无法单纯根据某个容器的 CPU 份额来确定有多少 CPU 资源分配给它，资源分配结果取决于同时运行的其他容器的 CPU 分配和容器中进程运行情况。
换句话说：通过 cpu share 可以设置容器使用 CPU 的优先级。
比如在 host 中启动了两个容器：
docker run --name "container_A" -c 1024 ubuntu
docker run --name "container_B" -c 512 ubuntu
container_A 的 cpu share 1024，是 container_B 的两倍。当两个容器都需要 CPU 资源时，container_A 可以得到的 CPU 是 container_B 的两倍。
需要特别注意的是，这种按权重分配 CPU 只会发生在 CPU 资源紧张的情况下。如果 container_A 处于空闲状态，这时，为了充分利用 CPU 资源，container_B 也可以分配到全部可用的 CPU。
下面我们继续用 ubuntu-with-stress 做实验。
-
启动 container_A，cpu share 为 1024：
bash[root@docker ~]# docker run --name "container_A" -it -c 1024 ubuntu-with-stress --cpu 4 -v stress: info: [1] dispatching hogs: 4 cpu, 0 io, 0 vm, 0 hdd stress: dbug: [1] using backoff sleep of 12000us stress: dbug: [1] --> hogcpu worker 4 [7] forked stress: dbug: [1] using backoff sleep of 9000us stress: dbug: [1] --> hogcpu worker 3 [8] forked stress: dbug: [1] using backoff sleep of 6000us stress: dbug: [1] --> hogcpu worker 2 [9] forked stress: dbug: [1] using backoff sleep of 3000us stress: dbug: [1] --> hogcpu worker 1 [10] forked #再开一个窗口 #使用如下命令，创建容器，则最终生成的 cgroup 的 CPU 份额配置可以下面的文件中找到。 [root@docker ~]# cat /sys/fs/cgroup/cpu/docker/<容器长ID>/cpu.shares 1024--cpu用来设置工作线程的数量。因为当前 host 有 4颗 CPU，所以要4个工作线程才能将 CPU 压满。如果 host 有多颗 CPU，则需要相应增加--cpu的数量。 -
再开一个窗口，启动 container_B，cpu share 为 512：
bash[root@docker ~]# docker run --name "container_B" -it -c 512 ubuntu-with-stress --cpu 4 -v stress: info: [1] dispatching hogs: 4 cpu, 0 io, 0 vm, 0 hdd stress: dbug: [1] using backoff sleep of 12000us stress: dbug: [1] --> hogcpu worker 4 [7] forked stress: dbug: [1] using backoff sleep of 9000us stress: dbug: [1] --> hogcpu worker 3 [8] forked stress: dbug: [1] using backoff sleep of 6000us stress: dbug: [1] --> hogcpu worker 2 [9] forked stress: dbug: [1] using backoff sleep of 3000us stress: dbug: [1] --> hogcpu worker 1 [10] forked [root@docker ~]# cat /sys/fs/cgroup/cpu/docker/<容器长ID>/cpu.shares 512 -
在 host 中执行
top，查看容器对 CPU 的使用情况：
因为我们host是4核所以开启了4个进程，为的就是充分让系统资源变得紧张，只有这样竞争资源，我们设定的资源比例才可以显现出来，如果只运行一个进程，他们会自动分配到空闲的CPU，这样比例就无法看出来。目前可以看到总比例是2:1。
container_A 消耗的 CPU 是 container_B 的两倍。
再开一个窗口
bash[root@docker docker]# docker stats
-
现在暂停 container_A：
bash[root@docker ~]# docker pause container_A container_A
-
top显示 container_B 在 container_A 空闲的情况下能够用满整颗 CPU：
029 export和import容器
export-容器导出
将容器导出为一个tar包
bash
[root@docker ~]# docker export --help
Usage: docker export [OPTIONS] CONTAINER
Export a container's filesystem as a tar archive
Aliases:
docker container export, docker export
Options:
-o, --output string Write to a file, instead of STDOUT不管此时这个容器是否处于运行状态，都可以导出为文件。
示例：
bash
# 创建容器httpd1用于测试
[root@docker ~]# docker run -d --name httpd1 httpd
e4f0a329c4df50ef0afb0bf21e22edc20e5a24c03ae64c6340aa2992d6e32525
[root@docker ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
e4f0a329c4df httpd "httpd-foreground" 3 minutes ago Up 3 minutes 80/tcp httpd1
[root@docker ~]# docker export httpd1 -o myhttpd.tar
[root@docker ~]# ls
myhttpd.tarimport-容器tar包导入
import将export导出的tar包导入成为镜像
bash
[root@docker ~]# docker import --help
Usage: docker import [OPTIONS] file|URL|- [REPOSITORY[:TAG]]
Import the contents from a tarball to create a filesystem image
Aliases:
docker image import, docker import
Options:
-c, --change list Apply Dockerfile instruction to the created image
-m, --message string Set commit message for imported image
--platform string Set platform if server is multi-platform capable示例：
bash
[root@docker ~]# docker import myhttpd.tar
sha256:9ae4699fa217a7240c73a50e93a8c1d359d22cf60869d350c8aab8b3c02aabcf
[root@docker ~]# docker import myhttpd.tar myweb:v1
sha256:9fcb90561d2014130ef19f9dd8af5efd7a0a4a2154907bc818ac6b887f13755c
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
myweb v1 9fcb90561d20 3 seconds ago 146MB
<none> <none> 9ae4699fa217 32 seconds ago 146MB
httpd latest 90f191b9781e 11 days ago 148MB
hello-world latest 74cc54e27dc4 6 months ago 10.1kB
[root@docker ~]#docker save和docker export对比：
docker save：将镜像保存为文件，save会保存该镜像的所有元数据和历史记录。docker export：将容器导出为文件，文件会丢失所有元数据和历史记录，仅保存容器当时的状态，再次导入会当作全新的镜像。
思考：docker export导出的文件是否可以使用docker load导入？
bash
[root@docker ~]# docker load -i myhttpd.tar
open /var/lib/docker/tmp/docker-import-3425397234/boot/json: no such file or directory思考：docker save导出的文件是否可以使用docker import导入？
答案：可以
提示：我们可以将docker save保存出来的文件解压后分析文件结构。
030 实现容器的底层技术
为了更好地理解容器的特性，本节我们将讨论容器的底层实现技术。
cgroup 和 namespace 是最重要的两种技术。cgroup 实现资源限额 namespace 实现资源隔离。
cgroup
cgroup 全称 Control Group。Linux 操作系统通过 cgroup 可以设置进程使用 CPU、内存 和 IO 资源的限额。相信你已经猜到了：前面我们看到的--cpu-shares、-m、--device-write-bps 实际上就是在配置 cgroup。
cgroup 到底长什么样子呢？我们可以在 /sys/fs/cgroup 中找到它。还是用例子来说明，启动一个容器，设置 --cpu-shares=512：
bash
[root@docker docker]# docker run -it --cpu-shares 512 ubuntu-with-stress -c 1 -v
stress: info: [1] dispatching hogs: 1 cpu, 0 io, 0 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogcpu worker 1 [7] forked查看容器的 ID：
在 /sys/fs/cgroup/cpu/docker 目录中，Linux 会为每个容器创建一个 cgroup 目录，以容器长ID 命名：
目录中包含所有与 cpu 相关的 cgroup 配置，文件 cpu.shares 保存的就是 --cpu-shares 的配置，值为 512。
同样的，/sys/fs/cgroup/memory/docker 和 /sys/fs/cgroup/blkio/docker 中保存的是内存以及 Block IO 的 cgroup 配置。
namespace
在每个容器中，我们都可以看到文件系统，网卡等资源，这些资源看上去是容器自己的。拿网卡来说，每个容器都会认为自己有一块独立的网卡，即使 host 上只有一块物理网卡。这种方式非常好，它使得容器更像一个独立的计算机。
Linux 实现这种方式的技术是 namespace。namespace 管理着 host 中全局唯一的资源，并可以让每个容器都觉得只有自己在使用它。换句话说，namespace 实现了容器间资源的隔离。
Linux 使用了六种 namespace，分别对应六种资源：Mount、UTS、IPC、PID、Network 和 User，下面我们分别讨论。
Mount namespace
Mount namespace 让容器看上去拥有整个文件系统。
容器有自己的 / 目录，可以执行 mount 和 umount 命令。当然我们知道这些操作只在当前容器中生效，不会影响到 host 和其他容器。
UTS namespace
简单的说，UTS namespace 让容器有自己的 hostname。 默认情况下，容器的 hostname 是它的短ID，可以通过 -h 或 --hostname 参数设置。
IPC namespace
IPC namespace 让容器拥有自己的共享内存和信号量（semaphore）来实现进程间通信，而不会与 host 和其他容器的 IPC 混在一起。
PID namespace
我们前面提到过，容器在 host 中以进程的形式运行。例如当前 host 中运行了两个容器：
bash
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a80f1f8b692c ubuntu "/bin/bash" 26 seconds ago Up 4 seconds interesting_davinci
835dd4eebda2 httpd "httpd-foreground" 56 seconds ago Up 55 seconds 80/tcp adoring_pare通过 ps axf 可以查看容器进程：
所有容器的进程都挂在 dockerd 进程下，同时也可以看到容器自己的子进程。 如果我们进入到某个容器，ps 就只能看到自己的进程了：
bash
[root@docker ~]# docker exec -it a80f1f8b692c bash
root@a80f1f8b692c:/#
root@a80f1f8b692c:/# ps axf
PID TTY STAT TIME COMMAND
17 pts/1 Ss 0:00 bash
25 pts/1 R+ 0:00 \_ ps axf
1 pts/0 Ss+ 0:00 /bin/bash而且进程的 PID 不同于 host 中对应进程的 PID，容器中 PID=1 的进程当然也不是 host 的 init 进程。也就是说：容器拥有自己独立的一套 PID，这就是 PID namespace 提供的功能。
Network namespace
Network namespace 让容器拥有自己独立的网卡、IP、路由等资源。我们会在后面网络章节详细讨论。
User namespace
User namespace 让容器能够管理自己的用户，host 不能看到容器中创建的用户。
bash
[root@docker ~]# docker exec -it a80f1f8b692c bash
root@a80f1f8b692c:/#
root@a80f1f8b692c:/# useradd dcr #容器中创建用户dcr
root@a80f1f8b692c:/#
root@a80f1f8b692c:/# exit
exit
[root@docker ~]# su - dcr #宿主机中并没有用户dcr
su: user dcr does not exist在容器中创建了用户 dcr，但 host 中并不会创建相应的用户。
小结
本章首先通过大量实验学习了容器的各种操作以及容器状态之间如何转换，然后讨论了限制容器使用 CPU、内存和 Block IO 的方法，最后学习了实现容器的底层技术：cgroup 和 namespace。
下面是容器的常用操作命令：
create 创建容器
run 运行容器
pause 暂停容器
unpause 取消暂停继续运行容器
stop 发送 SIGTERM 停止容器
kill 发送 SIGKILL 快速停止容器
start 启动容器
restart 重启容器
attach attach 到容器启动进程的终端
exec 在容器中启动新进程，通常使用 "-it" 参数
logs 显示容器启动进程的控制台输出，用 "-f" 持续打印
rm 从磁盘中删除容器
到这里，我们已经学习完了容器章节。下一节开始讨论容器网络。
第5章 网络
031 none和host网络的适用场景
本章开始讨论 Docker 网络。
我们会首先学习 Docker 提供的几种原生网络，以及如何创建自定义网络。然后探讨容器之间如何通信，以及容器与外界如何交互。
Docker 网络从覆盖范围可分为单个 host 上的容器网络和跨多个 host 的网络，本章重点讨论前一种。对于更为复杂的多 host 容器网络，我们会在后面进阶技术章节单独讨论。
Docker 安装时会自动在 host 上创建三个网络，我们可用 docker network ls 命令查看：
bash
[root@docker ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
a1b809382f0d bridge bridge local
6ad21ed9ea1f host host local
4e31521b27c6 none null local下面我们分别讨论它们。
none 网络
none网络的driver类型是null，IPAM字段为空。挂在none网络上的容器只有lo，无法与外界通信。
故名思议，none 网络就是什么都没有的网络。挂在这个网络下的容器除了 lo，没有其他任何网卡。容器创建时，可以通过 --network=none 指定使用 none 网络。
bash
[root@docker ~]# docker run -it --network=none busybox
/ #
/ # ifconfig
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)
/ #
/ # hostname
4027da12afaf我们不禁会问，这样一个封闭的网络有什么用呢？
其实还真有应用场景。封闭意味着隔离，一些对安全性要求高并且不需要联网的应用可以使用 none 网络。
比如某个容器的唯一用途是生成随机密码，就可以放到 none 网络中避免密码被窃取。
当然大部分容器是需要网络的，我们接着看 host 网络。
host 网络
挂在host网络上的容器共享宿主机的network namespace。即容器的网络配置与host网络配置完全一样。
连接到 host 网络的容器共享 Docker host 的网络栈，容器的网络配置与 host 完全一样。可以通过 --network=host 指定使用 host 网络。
bash
[root@docker ~]# docker run -it --network=host busybox #容器网络与宿主机相同
/ #
/ # ip l
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: ens160: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq qlen 1000
link/ether 00:0c:29:33:15:f6 brd ff:ff:ff:ff:ff:ff
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue
link/ether 02:42:02:fd:82:b3 brd ff:ff:ff:ff:ff:ff
/ #
/ # hostname #容器主机与宿主机相同
docker
/ #在容器中可以看到 host 的所有网卡，并且连 hostname 也是 host 的。host 网络的使用场景又是什么呢？
直接使用 Docker host 的网络最大的好处就是性能，如果容器对网络传输效率有较高要求，则可以选择 host 网络。当然不便之处就是牺牲一些灵活性，比如要考虑端口冲突问题，Docker host 上已经使用的端口就不能再用了。
Docker host 的另一个用途是让容器可以直接配置 host 网路。比如某些跨 host 的网络解决方案，其本身也是以容器方式运行的，这些方案需要对网络进行配置，比如管理 iptables。
下一节讨论应用更广的 bridge 网络。
032 学容器必须懂brige网络
上一节我们讨论了 none 和 host 类型的容器网络，本节学习应用最广泛也是默认的 bridge 网络。
Docker 安装时会创建一个 命名为 docker0 的 linux bridge，实际上它是 Linux 的一个 bridge (网桥)，可以理解为一个软件交换机，它会在挂载到它的网口之间进行转发。如果不指定--network，创建的容器默认都会挂到 docker0 上。
Docker 就创建了在主机和所有容器之间一个虚拟共享网络 当创建一个 Docker 容器的时候，同时会创建了一对 veth pair 接口（当数据包发送到一个接口时，另外一个接口也可以收到相同的数据包）, 这对接口
- 一端在容器内即 eth0；
- 另一端在本地并被挂载到 docker0 网桥，名称以 veth 开头（例如 vethAQI2QT）
通过这种方式，主机可以跟容器通信，容器之间也可以相互通信。
下面演示：
先配置yum源用于安装软件
bash
[root@docker ~]# cd /etc/yum.repos.d/
[root@docker yum.repos.d]# vim cloud.repo
[centos-openstack-victoria]
name=CentOS 8 - OpenStack victoria
baseurl=https://mirrors.aliyun.com/centos-vault/8-stream/cloud/x86_64/openstack-victoria/
enabled=1
gpgcheck=0
[root@docker yum.repos.d]# yum install -y bridge-utils
bash
[root@docker ~]# brctl show
bridge name bridge id STP enabled interfaces
docker0 8000.02420be905a5 no当前 docker0 上没有任何其他网络设备，我们创建一个容器看看有什么变化。
bash
[root@docker ~]# docker run -itd --name busybox1 busybox
5225d246f751dbfc4cdf745675d9c79d3de1b91dd4174268c35e671b9f1b0c80
[root@docker ~]# brctl show
bridge name bridge id STP enabled interfaces
docker0 8000.02420be905a5 no vethddb2744一个新的网络接口 vethddb2744 被挂到了 docker0 上，vethddb2744就是新创建容器的虚拟网卡。
下面看一下容器的网络配置。
bash
[root@docker ~]# docker exec -it busybox1 sh
/ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
# 容器里的网卡是24号网卡名字叫eth0，对面是25号网卡
24: eth0@if25: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
valid_lft forever preferred_lft forever容器有一个网卡 eth0@if25。大家可能会问了，为什么不是vethddb2744 呢？
实际上 eth0@if25 和 vethddb2744 是一对 veth pair。veth pair 是一种成对出现的特殊网络设备，可以把它们想象成由一根虚拟网线连接起来的一对网卡，网卡的一头（eth0@if25）在容器中，另一头（vethddb2744）挂在网桥 docker0 上，其效果就是将 eth0@if25 也挂在了 docker0 上。
在宿主机上查看IP地址，可以证明Docker0上的vethddb2744和容器中的eth0@if25 是一对
在宿主机看到有块网卡：25: vethddb2744@if24
宿主机的25号网卡：25: vethddb2744@if24 含义就是宿主机25号网卡对面连接了一块24号网卡，25号网卡的名字叫vethddb2744
证明了容器busybox1里的eth0连接到了docker0网桥的vethddb2744
我们还看到eth0@if25 已经配置了 IP 172.17.0.2，为什么是这个网段呢？让我们通过 docker network inspect bridge 看一下 bridge 网络的配置信息:
bash
[root@docker ~]# docker network inspect bridge
[
{
"Name": "bridge",
"Id": "9c8f4ff0c361c169536a912736d7a305b93abd9f3acc69fee066233260930a69",
"Created": "2025-07-31T13:31:35.155868533+08:00",
"Scope": "local",
"Driver": "bridge",
"EnableIPv6": false,
"IPAM": {
"Driver": "default",
"Options": null,
"Config": [
{
"Subnet": "172.17.0.0/16", `docker交换机默认分配的子网范围`
"Gateway": "172.17.0.1"
}
]
},
"Internal": false,
"Attachable": false,
"Ingress": false,
"ConfigFrom": {
"Network": ""
},
"ConfigOnly": false,
"Containers": {
"5225d246f751dbfc4cdf745675d9c79d3de1b91dd4174268c35e671b9f1b0c80": {
"Name": "busybox1",
"EndpointID": "ecc590ff010723831b97c0439ef9a9ca13fda695185d846d25662caecb066b7f",
"MacAddress": "02:42:ac:11:00:02",
"IPv4Address": "172.17.0.2/16", `运行容器后，交换机分配的地址`
"IPv6Address": ""
}
},
"Options": {
"com.docker.network.bridge.default_bridge": "true",
"com.docker.network.bridge.enable_icc": "true",
"com.docker.network.bridge.enable_ip_masquerade": "true",
"com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
"com.docker.network.bridge.name": "docker0",
"com.docker.network.driver.mtu": "1500"
},
"Labels": {}
}
]原来 bridge 网络配置的 subnet 就是 172.17.0.0/16，并且网关是 172.17.0.1。这个网关在哪儿呢？大概你已经猜出来了，就是 docker0。
bash
[root@docker ~]# ip a | grep docker0
3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0当前容器网络拓扑结构如图所示：
容器创建时，docker 会自动从 172.17.0.0/16 中分配一个 IP，这里 16 位的掩码保证有足够多的 IP 可以供容器使用。
除了 none, host, bridge 这三个自动创建的网络，用户也可以根据业务需要创建 user-defined 网络，下一节我们将详细讨论。
033 如何自定义容器网络？
除了 none, host, bridge 这三个自动创建的网络，用户也可以根据业务需要创建 user-defined 网络。
Docker 提供三种 user-defined 网络驱动：bridge, overlay 和 macvlan。overlay 和 macvlan 用于创建跨主机的网络，我们后面有章节单独讨论。
我们可通过 bridge 驱动创建类似前面默认的 bridge 网络，例如：
bash
[root@docker ~]# docker network create --driver bridge my_net
89f7bc11b602e84452ae01786113ac196a535f7296b9989ad941b3a48a5e6d04查看一下当前 host 的网络结构变化：
bash
[root@docker ~]# brctl show
bridge name bridge id STP enabled interfaces
br-89f7bc11b602 8000.0242194d039e no #my_net，看bridge name和刚才创建的my_net id一样
docker0 8000.02420be905a5 no vethddb2744 新增了一个网桥 br-89f7bc11b602，这里 br-89f7bc11b602 正好是新建 bridge 网络 my_net 的短 id。执行 docker network inspect 查看一下 my_net 的配置信息：
bash
[root@docker ~]# docker network inspect my_net
[
{
"Name": "my_net",
"Id": "89f7bc11b602e84452ae01786113ac196a535f7296b9989ad941b3a48a5e6d04",
"Created": "2025-07-31T15:57:17.487644996+08:00",
"Scope": "local",
"Driver": "bridge",
"EnableIPv6": false,
"IPAM": {
"Driver": "default",
"Options": {},
"Config": [
{
"Subnet": "172.18.0.0/16",
"Gateway": "172.18.0.1"
}
]
},
"Internal": false,
"Attachable": false,
"Ingress": false,
"ConfigFrom": {
"Network": ""
},
"ConfigOnly": false,
"Containers": {},
"Options": {},
"Labels": {}
}
]这里 172.18.0.0/16 是 Docker 自动分配的 IP 网段。
我们可以自己指定 IP 网段吗？
答案是：可以。
只需在创建网段时指定 --subnet 和 --gateway 参数：
bash
[root@docker ~]# docker network create --driver bridge --subnet 172.22.16.0/24 --gateway 172.22.16.1 my_net2
ec761bc51778f67c2245af72fd969f00cd517ee617a10a70dc01904f9c10279d
[root@docker ~]# brctl show
bridge name bridge id STP enabled interfaces
br-89f7bc11b602 8000.0242194d039e no #my_net
br-ec761bc51778 8000.02427fa54b88 no #my_net2
docker0 8000.02420be905a5 no vethddb2744
[root@docker ~]# docker network inspect my_net2
[
{
"Name": "my_net2",
"Id": "ec761bc51778f67c2245af72fd969f00cd517ee617a10a70dc01904f9c10279d",
"Created": "2025-07-31T16:00:06.021244096+08:00",
"Scope": "local",
"Driver": "bridge",
"EnableIPv6": false,
"IPAM": {
"Driver": "default",
"Options": {},
"Config": [
{
"Subnet": "172.22.16.0/24", #确实是指定的网段
"Gateway": "172.22.16.1" #确实是指定的网关地址
}
]
},
"Internal": false,
"Attachable": false,
"Ingress": false,
"ConfigFrom": {
"Network": ""
},
"ConfigOnly": false,
"Containers": {},
"Options": {},
"Labels": {}
}
]这里我们创建了新的 bridge 网络 my_net2，网段为 172.22.16.0/24，网关为 172.22.16.1。与前面一样，网关在 my_net2 对应的网桥 br-ec761bc51778 上：
bash
[root@docker ~]# brctl show
bridge name bridge id STP enabled interfaces
br-89f7bc11b602 8000.0242194d039e no #my_net
br-ec761bc51778 8000.02427fa54b88 no #my_net2
docker0 8000.02420be905a5 no vethddb2744
#同时宿主机上出现了与网桥my_net,my_net2同名的网卡
#查看my_net2网卡
[root@docker ~]# ip a | grep br-ec761bc51778
27: br-ec761bc51778: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default
inet 172.22.16.1/24 brd 172.22.16.255 scope global br-ec761bc51778容器要使用新的网络，需要在启动时通过 --network 指定：
bash
[root@docker ~]# docker run -it --network=my_net2 --name busybox2 busybox
/ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
28: eth0@if29: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
link/ether 02:42:ac:16:10:02 brd ff:ff:ff:ff:ff:ff
inet 172.22.16.2/24 brd 172.22.16.255 scope global eth0
valid_lft forever preferred_lft forever
/ # ctrl+P,ctrl+q退出容器
[root@docker ~]# brctl show
bridge name bridge id STP enabled interfaces
br-89f7bc11b602 8000.0242194d039e no
br-ec761bc51778 8000.02427fa54b88 no veth02dd704 #my_net2上新增的接口veth02dd704连接容器busybox2
docker0 8000.02420be905a5 no vethddb2744容器分配到的 IP 为 172.22.16.2。
到目前为止，容器的 IP 都是 docker 自动从 subnet 中分配，我们能否指定一个静态 IP 呢？
答案是：可以，通过--ip指定。
bash
[root@docker ~]# docker run -it --network=my_net2 --ip 172.22.16.8 --name busybox3 busybox
/ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
30: eth0@if31: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
link/ether 02:42:ac:16:10:08 brd ff:ff:ff:ff:ff:ff
inet 172.22.16.8/24 brd 172.22.16.255 scope global eth0 #确实是指定的IP
valid_lft forever preferred_lft forever
/ # ctrl+P,ctrl+q退出容器
[root@docker ~]# brctl show
bridge name bridge id STP enabled interfaces
br-89f7bc11b602 8000.0242194d039e no #my_net
br-ec761bc51778 8000.02427fa54b88 no veth02dd704 #my_net2
veth5fbb7f6 #veth5fbb7f6是连接busybox3
docker0 8000.02420be905a5 no vethddb2744注：只有使用 --subnet 创建的网络才能指定静态 IP。
my_net 创建时没有指定 --subnet，如果指定静态 IP 报错如下：
bash
[root@docker ~]# docker run -it --network=my_net --ip 172.18.0.8 busybox
docker: Error response from daemon: invalid config for network my_net: invalid endpoint settings:
user specified IP address is supported only when connecting to networks with user configured subnets.
See 'docker run --help'.好了，我们来看看当前 docker host 的网络拓扑结构。
下一节讨论这几个容器之间的连通性。
034 理解容器之间的连通性
通过前面小节的实践，当前 docker host 的网络拓扑结构如下图所示，今天我们将讨论这几个容器之间的连通性。
busybox2、busybox3 容器都挂在 my_net2 上，应该能够互通，我们验证一下：
bash
# 登陆busybox2 ping busybox3
[root@docker ~]# docker exec -it busybox2 sh
/ # ifconfig eth0
eth0 Link encap:Ethernet HWaddr 02:42:AC:16:10:02
inet addr:172.22.16.2 Bcast:172.22.16.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:18 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:1436 (1.4 KiB) TX bytes:0 (0.0 B)
/ # ping -c 3 172.22.16.8
PING 172.22.16.8 (172.22.16.8): 56 data bytes
64 bytes from 172.22.16.8: seq=0 ttl=64 time=0.197 ms
64 bytes from 172.22.16.8: seq=1 ttl=64 time=0.137 ms
64 bytes from 172.22.16.8: seq=2 ttl=64 time=0.158 ms
--- 172.22.16.8 ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max = 0.137/0.164/0.197 ms
/ #
# ping my_net2网关地址
/ # ping -c 3 172.22.16.1
PING 172.22.16.1 (172.22.16.1): 56 data bytes
64 bytes from 172.22.16.1: seq=0 ttl=64 time=0.149 ms
64 bytes from 172.22.16.1: seq=1 ttl=64 time=0.116 ms
64 bytes from 172.22.16.1: seq=2 ttl=64 time=0.182 ms
--- 172.22.16.1 ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max = 0.116/0.149/0.182 ms可见同一网络中的容器、网关之间都是可以通信的。
my_net2 与默认 bridge 网络(docker0)能通信吗？
从拓扑图可知，两个网络属于不同的网桥，应该不能通信，我们通过实验验证一下，让 busybox2 容器 ping buxybox1 容器：
bash
/ # ping -c 3 172.17.0.2
PING 172.17.0.2 (172.17.0.2): 56 data bytes
--- 172.17.0.2 ping statistics ---
3 packets transmitted, 0 packets received, 100% packet loss
/ #确实 ping 不通，符合预期。
"等等！不同的网络如果加上路由应该就可以通信了吧？"
这是一个非常非常好的想法。
确实，如果 host 上对每个网络的都有一条路由，同时操作系统上打开了 ip forwarding，host 就成了一个路由器，挂接在不同网桥上的网络就能够相互通信。下面我们来看看 docker host 满不满足这些条件呢？
ip r 查看 host 上的路由表：
bash
[root@docker ~]# ip r
default via 192.168.108.2 dev ens160 proto static metric 100
172.17.0.0/16 dev docker0 proto kernel scope link src 172.17.0.1
172.18.0.0/16 dev br-a6eff42dc3c6 proto kernel scope link src 172.18.0.1 linkdown
172.22.16.0/24 dev br-c0fc7bdf8143 proto kernel scope link src 172.22.16.1
192.168.108.0/24 dev ens160 proto kernel scope link src 192.168.108.30 metric 100
[root@docker ~]#172.17.0.0/16 和 172.22.16.0/24 两个网络的路由都定义好了。再看看 ip forwarding：
bash
[root@docker ~]# sysctl net.ipv4.ip_forward
net.ipv4.ip_forward = 1ip forwarding 也已经启用了。
条件都满足，为什么不能通行呢？
我们还得看看 iptables：
bash
[root@docker ~]# iptables-save
# Generated by iptables-save v1.8.5 on Thu Jul 31 17:09:34 2025
*filter
:INPUT ACCEPT [69184:9702316]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [113709:49882234]
:DOCKER - [0:0]
:DOCKER-ISOLATION-STAGE-1 - [0:0]
:DOCKER-ISOLATION-STAGE-2 - [0:0]
:DOCKER-USER - [0:0]
-A FORWARD -j DOCKER-USER
-A FORWARD -j DOCKER-ISOLATION-STAGE-1
-A FORWARD -o br-ec761bc51778 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -o br-ec761bc51778 -j DOCKER
-A FORWARD -i br-ec761bc51778 ! -o br-ec761bc51778 -j ACCEPT
-A FORWARD -i br-ec761bc51778 -o br-ec761bc51778 -j ACCEPT
-A FORWARD -o br-89f7bc11b602 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -o br-89f7bc11b602 -j DOCKER
-A FORWARD -i br-89f7bc11b602 ! -o br-89f7bc11b602 -j ACCEPT
-A FORWARD -i br-89f7bc11b602 -o br-89f7bc11b602 -j ACCEPT
-A FORWARD -o docker0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A FORWARD -o docker0 -j DOCKER
-A FORWARD -i docker0 ! -o docker0 -j ACCEPT
-A FORWARD -i docker0 -o docker0 -j ACCEPT
-A DOCKER-ISOLATION-STAGE-1 -i br-ec761bc51778 ! -o br-ec761bc51778 -j DOCKER-ISOLATION-STAGE-2
-A DOCKER-ISOLATION-STAGE-1 -i br-89f7bc11b602 ! -o br-89f7bc11b602 -j DOCKER-ISOLATION-STAGE-2
-A DOCKER-ISOLATION-STAGE-1 -i docker0 ! -o docker0 -j DOCKER-ISOLATION-STAGE-2
-A DOCKER-ISOLATION-STAGE-1 -j RETURN
-A DOCKER-ISOLATION-STAGE-2 -o br-ec761bc51778 -j DROP
-A DOCKER-ISOLATION-STAGE-2 -o br-89f7bc11b602 -j DROP
-A DOCKER-ISOLATION-STAGE-2 -o docker0 -j DROP
-A DOCKER-ISOLATION-STAGE-2 -j RETURN
-A DOCKER-USER -j RETURN
COMMIT
# Completed on Thu Jul 31 17:09:34 2025
# Generated by iptables-save v1.8.5 on Thu Jul 31 17:09:34 2025
*security
:INPUT ACCEPT [69166:9698194]
:FORWARD ACCEPT [34:2856]
:OUTPUT ACCEPT [113709:49882234]
COMMIT
# Completed on Thu Jul 31 17:09:34 2025
# Generated by iptables-save v1.8.5 on Thu Jul 31 17:09:34 2025
*raw
:PREROUTING ACCEPT [69554:9733396]
:OUTPUT ACCEPT [113709:49882234]
COMMIT
# Completed on Thu Jul 31 17:09:34 2025
# Generated by iptables-save v1.8.5 on Thu Jul 31 17:09:34 2025
*mangle
:PREROUTING ACCEPT [69554:9733396]
:INPUT ACCEPT [69184:9702316]
:FORWARD ACCEPT [370:31080]
:OUTPUT ACCEPT [113709:49882234]
:POSTROUTING ACCEPT [113743:49885090]
COMMIT
# Completed on Thu Jul 31 17:09:34 2025
# Generated by iptables-save v1.8.5 on Thu Jul 31 17:09:34 2025
*nat
:PREROUTING ACCEPT [367:33182]
:INPUT ACCEPT [9:500]
:POSTROUTING ACCEPT [294:23341]
:OUTPUT ACCEPT [291:23089]
:DOCKER - [0:0]
-A PREROUTING -m addrtype --dst-type LOCAL -j DOCKER
-A POSTROUTING -s 172.22.16.0/24 ! -o br-ec761bc51778 -j MASQUERADE
-A POSTROUTING -s 172.18.0.0/16 ! -o br-89f7bc11b602 -j MASQUERADE
-A POSTROUTING -s 172.17.0.0/16 ! -o docker0 -j MASQUERADE
-A OUTPUT ! -d 127.0.0.0/8 -m addrtype --dst-type LOCAL -j DOCKER
-A DOCKER -i br-ec761bc51778 -j RETURN
-A DOCKER -i br-89f7bc11b602 -j RETURN
-A DOCKER -i docker0 -j RETURN
COMMIT
# Completed on Thu Jul 31 17:09:34 2025原因就在这里了：iptables DROP 掉了网桥 docker0 与 br-ec761bc51778(my_net2) 之间双向的流量。
bash
[root@docker ~]# brctl show
bridge name bridge id STP enabled interfaces
br-89f7bc11b602 8000.0242194d039e no
br-ec761bc51778（mynet2） 8000.02427fa54b88 no veth02dd704
veth5fbb7f6
docker0 8000.02420be905a5 no vethddb2744从规则的命名 DOCKER-ISOLATION 可知 docker 在设计上就是要隔离不同的 netwrok。
那么接下来的问题是：怎样才能让 busybox1与busybox2 通信呢？
答案是：为 busybox1 容器添加一块 my_net2 的网卡。这个可以通过docker network connect 命令实现。
bash
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
0899976a1c59 busybox "sh" About an hour ago Up About an hour busybox3
e9da18f962d6 busybox "sh" About an hour ago Up About an hour busybox2
5225d246f751 busybox "sh" About an hour ago Up About an hour busybox1
[root@docker ~]# docker network connect my_net2； busybox1我们在 httpd 容器中查看一下网络配置：
bash
[root@docker ~]# docker exec -it busybox1 sh
/ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
24: eth0@if25: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
valid_lft forever preferred_lft forever
32: eth1@if33: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
link/ether 02:42:ac:16:10:03 brd ff:ff:ff:ff:ff:ff
inet 172.22.16.3/24 brd 172.22.16.255 scope global eth1
valid_lft forever preferred_lft forever
[root@docker ~]# brctl show
bridge name bridge id STP enabled interfaces
br-89f7bc11b602 8000.0242194d039e no
br-ec761bc51778 8000.02427fa54b88 no veth02dd704 #busybox2
veth5fbb7f6 #busybox3
veth6642cc9 #busybox1
docker0 8000.02420be905a5 no vethddb2744容器中增加了一个网卡 eth1，分配了 my_net2 的 IP 172.22.16.3。现在 busybox2 应该能够访问busybox1 了，验证一下：
bash
[root@docker ~]# docker exec -it busybox2 sh
/ # ping -c 3 172.22.16.3
PING 172.22.16.3 (172.22.16.3): 56 data bytes
64 bytes from 172.22.16.3: seq=0 ttl=64 time=0.199 ms
64 bytes from 172.22.16.3: seq=1 ttl=64 time=0.134 ms
64 bytes from 172.22.16.3: seq=2 ttl=64 time=0.141 ms
--- 172.22.16.3 ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max = 0.134/0.158/0.199 ms
/ #busybox 能够 ping 到 busybox2。当前网络结构如图所示：
下一节我们讨论容器间通信的三种方式。
035 容器通信的三种方式
容器之间可通过 IP，Docker DNS Server 或 joined 容器三种方式通信。
IP 通信
从上一节的例子可以得出这样一个结论：两个容器要能通信，必须要有属于同一个网络的网卡。
满足这个条件后，容器就可以通过 IP 交互了。具体做法是在容器创建时通过 --network 指定相应的网络，或者通过 docker network connect 将现有容器加入到指定网络。可参考上一节 busybox 的例子，这里不再赘述。
Docker DNS Server
通过 IP 访问容器虽然满足了通信的需求，但还是不够灵活。因为我们在部署应用之前可能无法确定 IP，部署之后再指定要访问的 IP 会比较麻烦。对于这个问题，可以通过 docker 自带的 DNS 服务解决。
从 Docker 1.10 版本开始，docker daemon 实现了一个内嵌的 DNS server，使容器可以直接通过"容器名"通信。方法很简单，只要在启动时用 --name 为容器命名就可以了。
下面启动两个容器 bbox1 和 bbox2：
bash
[root@docker ~]# docker run -it --network my_net2 --name bbox1 busybox
/ #
ctrl_p,ctrl_q退出容器
[root@docker ~]# docker run -it --network my_net2 --name bbox2 busybox
/ #
ctrl_p,ctrl_q退出容器然后，bbox2 就可以直接 ping 到 bbox1 了：
bash
[root@docker ~]# docker exec -it bbox2 sh
/ #
/ # ping -c 3 bbox1
PING bbox1 (172.22.16.2): 56 data bytes
64 bytes from 172.22.16.2: seq=0 ttl=64 time=0.177 ms
64 bytes from 172.22.16.2: seq=1 ttl=64 time=0.161 ms
64 bytes from 172.22.16.2: seq=2 ttl=64 time=0.187 ms
--- bbox1 ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max = 0.161/0.175/0.187 ms使用 docker DNS 有个限制：只能在 user-defined 网络中使用。也就是说，默认的 bridge 网络是无法使用 DNS 的。下面验证一下：
创建 bbox3 和 bbox4，均连接到 bridge 网络。
bash
[root@docker ~]# docker run -it --name bbox3 busybox
/ #
ctrl_p,ctrl_q退出容器
[root@docker ~]# docker run -it --name bbox4 busybox
/ #
ctrl_p,ctrl_q退出容器bbox4 无法 ping 到 bbox3。
bash
[root@docker ~]# docker exec -it bbox4 sh
/ # ping -c 3 bbox3
ping: bad address 'bbox3'
/ #joined 容器
joined 容器是另一种实现容器间通信的方式。
joined 容器非常特别，它可以使两个或多个容器共享一个网络栈，共享网卡和配置信息，joined 容器之间可以通过 127.0.0.1 直接通信。请看下面的例子：
先创建一个 httpd 容器，名字为 web1。
bash
[root@docker ~]# docker run -d -it --name web1 httpd
f7641c43eb7021724e869f77bd4541e909ebf0968fc35e6a43e8e674d046ef3f下面我们查看一下 web1 的网络：
bash
[root@docker ~]# docker exec -it web1 bash
root@1d5181ce7a85:/usr/local/apache2# apt-get update
root@1d5181ce7a85:/usr/local/apache2# apt-get install iproute2 -y
root@1d5181ce7a85:/usr/local/apache2# ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
18: eth0@if19: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
valid_lft forever preferred_lft forever
# 也可以直接通过hostname -I观察IP地址然后创建 busybox 容器并通过 --network=container:web1 指定 jointed 容器为 web1：
请注意 busybox 容器中的网络配置信息
bash
[root@docker ~]# docker run -it --network container:web1 busybox
/ #
/ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
18: eth0@if19: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue
link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff
inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
valid_lft forever preferred_lft forever
/ #看！busybox 和 web1 的网卡 mac 地址与 IP 完全一样，它们共享了相同的网络栈。busybox 可以直接用 127.0.0.1 访问 web1 的 http 服务。
bash
/ # wget 127.0.0.1
Connecting to 127.0.0.1 (127.0.0.1:80)
saving to 'index.html'
index.html 100% |***************************| 45 0:00:00 ETA
'index.html' saved
/ #
/ # cat index.html
<html><body><h1>It works!</h1></body></html>
/ #joined 容器非常适合以下场景：
- 不同容器中的程序希望通过 loopback 高效快速地通信，比如 web server 与 app server。
- 希望监控其他容器的网络流量，比如运行在独立容器中的网络监控程序。
容器之间的通信我们已经搞清楚了，接下来要考虑的是容器如何与外部世界通信？这将是下一节的主题。
036 容器如何访问外部世界
前面我们已经解决了容器间通信的问题，接下来讨论容器如何与外部世界通信。这里涉及两个方向：
- 容器访问外部世界
- 外部世界访问容器
容器访问外部世界
在我们当前的实验环境下，docker host 是可以访问外网的。
BASH
[root@docker ~]# ping -c 3 www.baidu.com
PING www.baidu.com (223.109.82.6) 56(84) bytes of data.
64 bytes from 223.109.82.6 (223.109.82.6): icmp_seq=1 ttl=128 time=67.8 ms
64 bytes from 223.109.82.6 (223.109.82.6): icmp_seq=2 ttl=128 time=13.0 ms
64 bytes from 223.109.82.6 (223.109.82.6): icmp_seq=3 ttl=128 time=12.5 ms
--- www.baidu.com ping statistics ---
3 packets transmitted, 3 received, 0% packet loss, time 2004ms
rtt min/avg/max/mdev = 12.454/31.074/67.754/25.937 ms我们看一下容器是否也能访问外网呢？
bash
[root@docker ~]# docker run -it --name test1 busybox
/ #
/ # ping -c 3 www.baidu.com
PING www.baidu.com (223.109.82.6): 56 data bytes
64 bytes from 223.109.82.6: seq=0 ttl=127 time=21.240 ms
64 bytes from 223.109.82.6: seq=1 ttl=127 time=14.987 ms
64 bytes from 223.109.82.6: seq=2 ttl=127 time=14.651 ms
--- www.baidu.com ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max = 14.651/16.959/21.240 ms可见，容器默认就能访问外网。
请注意：这里外网指的是容器网络以外的网络环境，并非特指 internet。
现象很简单，但更重要的：我们应该理解现象下的本质。
在上面的例子中，busybox 位于 docker0 这个私有 bridge 网络中（172.17.0.0/16），当 busybox 从容器向外 ping 时，数据包是怎样到达 www.baidu.com 的呢？
这里的关键就是 NAT。我们查看一下 docker host 上的 iptables 规则：
bash
[root@docker ~]# iptables -t nat -S
-P PREROUTING ACCEPT
-P INPUT ACCEPT
-P POSTROUTING ACCEPT
-P OUTPUT ACCEPT
-N DOCKER
-A PREROUTING -m addrtype --dst-type LOCAL -j DOCKER
-A POSTROUTING -s 172.17.0.0/16 ! -o docker0 -j MASQUERADE
-A POSTROUTING -s 172.19.0.0/16 ! -o br-6936dc39839e -j MASQUERADE
-A POSTROUTING -s 172.22.16.0/24 ! -o br-c0fc7bdf8143 -j MASQUERADE
-A OUTPUT ! -d 127.0.0.0/8 -m addrtype --dst-type LOCAL -j DOCKER
-A DOCKER -i docker0 -j RETURN
-A DOCKER -i br-6936dc39839e -j RETURN
-A DOCKER -i br-c0fc7bdf8143 -j RETURN
[root@docker ~]#在 NAT 表中，有这么一条规则：
-A POSTROUTING -s 172.17.0.0/16 ! -o docker0 -j MASQUERADE
其含义是：如果网桥 docker0 收到来自 172.17.0.0/16 网段的外出包，把它交给 MASQUERADE 处理。而 MASQUERADE 的处理方式是将包的源地址替换成 host 的地址发送出去，即做了一次网络地址转换（NAT）。
下面我们通过 tcpdump 查看地址是如何转换的。先查看 docker host 的路由表：
bash
[root@docker ~]# ip r
default via 192.168.108.2 dev ens160 proto static metric 100
172.17.0.0/16 dev docker0 proto kernel scope link src 172.17.0.1
172.19.0.0/16 dev br-6936dc39839e proto kernel scope link src 172.19.0.1 linkdown
172.22.16.0/24 dev br-c0fc7bdf8143 proto kernel scope link src 172.22.16.1 linkdown
192.168.108.0/24 dev ens160 proto kernel scope link src 192.168.108.30 metric 100默认路由通过 ens160 发出去，所以我们要同时监控 ens160 和 docker0 上的 icmp（ping）数据包。
使用tcpdump观察现象
bash
[root@docker ~]# yum install -y tcpdump
[root@docker ~]# tcpdump -i docker0 -n icmp
dropped privs to tcpdump
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on docker0, link-type EN10MB (Ethernet), capture size 262144 bytes
#再开一个窗口
[root@docker ~]# tcpdump -i ens160 -n icmp
dropped privs to tcpdump
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on ens160, link-type EN10MB (Ethernet), capture size 262144 bytes再开一个窗口， busybox ping www.baidu.com
bash
[root@docker ~]# docker run -it busybox
/ #
/ # ping -c 3 www.baidu.com
PING www.baidu.com (223.109.82.41): 56 data bytes
64 bytes from 223.109.82.41: seq=0 ttl=127 time=12.503 ms
64 bytes from 223.109.82.41: seq=1 ttl=127 time=13.380 ms
64 bytes from 223.109.82.41: seq=2 ttl=127 time=11.507 ms
--- www.baidu.com ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max = 11.507/12.463/13.380 ms
/ #tcpdump 输出如下：
bash
[root@docker ~]# tcpdump -i docker0 -n icmp
dropped privs to tcpdump
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on docker0, link-type EN10MB (Ethernet), capture size 262144 bytes
15:23:42.854951 IP 172.17.0.2 > 223.109.82.41: ICMP echo request, id 7, seq 0, length 64
15:23:42.870473 IP 223.109.82.41 > 172.17.0.2: ICMP echo reply, id 7, seq 0, length 64
15:23:43.857551 IP 172.17.0.2 > 223.109.82.41: ICMP echo request, id 7, seq 1, length 64
15:23:43.880065 IP 223.109.82.41 > 172.17.0.2: ICMP echo reply, id 7, seq 1, length 64
15:23:44.869116 IP 172.17.0.2 > 223.109.82.41: ICMP echo request, id 7, seq 2, length 64
15:23:44.883777 IP 223.109.82.41 > 172.17.0.2: ICMP echo reply, id 7, seq 2, length 64docker0 收到 busybox 的 ping 包，源地址为容器 IP 172.17.0.2，这没问题，交给 MASQUERADE 处理。这时，在 ens160 上我们看到了变化：
bash
[root@docker ~]# tcpdump -i ens160 -n icmp
dropped privs to tcpdump
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on ens160, link-type EN10MB (Ethernet), capture size 262144 bytes
15:25:41.886472 IP 192.168.108.30 > 223.109.82.41: ICMP echo request, id 8, seq 0, length 64
15:25:41.906738 IP 223.109.82.41 > 192.168.108.30: ICMP echo reply, id 8, seq 0, length 64
15:25:42.887752 IP 192.168.108.30 > 223.109.82.41: ICMP echo request, id 8, seq 1, length 64
15:25:42.899613 IP 223.109.82.41 > 192.168.108.30: ICMP echo reply, id 8, seq 1, length 64
15:25:43.889467 IP 192.168.108.30 > 223.109.82.41: ICMP echo request, id 8, seq 2, length 64
15:25:43.904277 IP 223.109.82.41 > 192.168.108.30: ICMP echo reply, id 8, seq 2, length 64ping 包的源地址变成了 ens160 的 IP 192.168.108.130
这就是 iptable NAT 规则处理的结果，从而保证数据包能够到达外网。下面用一张图来说明这个过程：
- busybox 发送 ping 包：172.17.0.2 > www.baidu.com。
- docker0 收到包，发现是发送到外网的，交给 NAT 处理。
- NAT 将源地址换成 ens160的 IP：192.168.108.30 > www.baidu.com。
- ping 包从 ens160 发送出去，到达 www.baidu.com。
通过 NAT，docker 实现了容器对外网的访问。
下一节我们讨论另一个方向的流量：外部世界如何访问容器。
037 外部世界如何访问容器
上节我们学习了容器如何访问外部网络，今天讨论另一个方向：外部网络如何访问到容器？
答案是：端口映射。
docker 可将容器对外提供服务的端口映射到 host 的某个端口，外网通过该端口访问容器。容器启动时通过-p参数映射端口：
容器启动后，可通过 docker ps 或者 docker port 查看到 host 映射的端口。在上面的例子中，httpd 容器的 80 端口被映射到 host 32768 上，这样就可以通过 <host ip>:<32768> 访问容器的 web 服务了。
bash
[root@docker ~]# curl 192.168.108.30:32768
<html><body><h1>It works!</h1></body></html>
除了映射动态端口，也可在 -p 中指定映射到 host 某个特定端口，例如可将 80 端口映射到 host 的 8080 端口：
bash
[root@docker ~]# docker run -d -p 8080:80 httpd
25b04cb7f6d6c012c609251a425475fcf7da03c93feb20c1d951eb45cb1ef79b
[root@docker ~]#
[root@docker ~]# curl 192.168.108.30:8080
<html><body><h1>It works!</h1></body></html>每一个映射的端口，host 都会启动一个 docker-proxy 进程来处理访问容器的流量：
以 0.0.0.0:8080->80/tcp 为例分析整个过程：
- docker-proxy 监听 host 的 8080 端口。
- 当 curl 访问 192.168.108.30:8080时，docker-proxy 转发给容器 172.17.0.3:80。
- httpd 容器响应请求并返回结果。
实战：安装tomcat
docker hub上面查找tomcat镜像
bash
[root@docker ~]# docker search tomcat
NAME DESCRIPTION STARS OFFICIAL
tomcat Apache Tomcat is an open source implementati... 3751 [OK]
bitnami/tomcat Bitnami container image for Tomcat 52
bitnamicharts/tomcat Bitnami Helm chart for Apache Tomcat 0
rootpublic/tomcat 0
chainguard/tomcat Build, ship and run secure software with Cha... 0
islandora/tomcat Base tomcat image used for java services. 0
vulhub/tomcat 0
openeuler/tomcat 0
tomcat/tomcat01 0
jelastic/tomcat An image of the Tomcat Java application serv... 4
rightctrl/tomcat CentOS , Oracle Java, tomcat application ssl... 7
amd64/tomcat Apache Tomcat is an open source implementati... 10
softwareplant/tomcat Tomcat images for jira-cloud testing 0
arm64v8/tomcat Apache Tomcat is an open source implementati... 13
appsvc/tomcat 1
s390x/tomcat Apache Tomcat is an open source implementati... 0
ppc64le/tomcat Apache Tomcat is an open source implementati... 1
arm32v7/tomcat Apache Tomcat is an open source implementati... 12
awscory/tomcat tomcat 0
devbeta/tomcat 0
tutum/tomcat Base docker image to run a Tomcat applicatio... 11
qasymphony/tomcat Tomcat images 1
hegand/tomcat docker-tomcat 0
techangels/tomcat 0
cloudesire/tomcat Tomcat server, 6/7/8 14从docker hub上拉取tomcat镜像到本地
bash
[root@docker ~]# docker pull tomcatdocker images查看是否有拉取到的tomcat
bash
[root@docker ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
httpd latest 90f191b9781e 2 weeks ago 148MB
tomcat latest 9ca267cc83c7 3 weeks ago 468MB
hello-world latest 74cc54e27dc4 6 months ago 10.1kB使用tomcat镜像创建容器实例(也叫运行镜像)
bash
[root@docker ~]# docker run -itd -p 8080:8080 tomcat
92d78922526ba2a54ef63c48d2fec80b10997027de93457a4e2d56d7ea7448e2访问tomcat首页
把webapps.dist目录换成webapps
bash
#查看刚才创建的tomcat容器ID
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
92d78922526b tomcat "catalina.sh run" 2 minutes ago Up 2 minutes 0.0.0.0:8080->8080/tcp, :::8080->8080/tcp fervent_brahmagupta
#进入tomcat容器
[root@docker ~]# docker exec -it 92d bash
#查看webapps文件夹为空
root@92d78922526b:/usr/local/tomcat# ls webapps
root@92d78922526b:/usr/local/tomcat#
#文件在webapps.dist
root@92d78922526b:/usr/local/tomcat# ls webapps.dist/
docs examples host-manager manager ROOT
#用webapps.dist替换webapps
root@92d78922526b:/usr/local/tomcat# rm -r webapps
root@92d78922526b:/usr/local/tomcat# mv webapps.dist webapps再次访问tomcat
思考：我想要基于tomcat镜像做出一个能够直接访问的tomcat镜像该如何做？
答：使用Dockerfile
本章小结
在这一章我们首先学习了 Docker 的三种网络：none, host 和 bridge 并讨论了它们的不同使用场景；然后我们实践了创建自定义网络；最后详细讨论了如何实现容器与容器之间，容器与外部网络之间的通信。
本章重点关注的是单个主机内的容器网络，下一节开始学习 Docker 存储。
第6章 存储
038 Docker的两类存储资源
我们从本章开始讨论 Docker 存储。
Docker 为容器提供了两种存放数据的资源：
- 由 storage driver 管理的镜像层和容器层。
- Data Volume。
我们会详细讨论它们的原理和特性。
storage driver
在前面镜像章节我们学习到 Docker 镜像的分层结构，简单回顾一下。
容器由最上面一个可写的容器层，以及若干只读的镜像层组成，容器的数据就存放在这些层中。这样的分层结构最大的特性是 Copy-on-Write：
- 新数据会直接存放在最上面的容器层。
- 修改现有数据会先从镜像层将数据复制到容器层，修改后的数据直接保存在容器层中，镜像层保持不变。
- 如果多个层中有命名相同的文件，用户只能看到最上面那层中的文件。
分层结构使镜像和容器的创建、共享以及分发变得非常高效，而这些都要归功于 Docker storage driver。正是 storage driver 实现了多层数据的堆叠并为用户提供一个单一的合并之后的统一视图。
Docker 支持多种 storage driver，有 AUFS、Device Mapper、Btrfs、OverlayFS、VFS 和 ZFS。它们都能实现分层的架构，同时又有各自的特性。对于 Docker 用户来说，具体选择使用哪个 storage driver 是一个难题，因为：
- 没有哪个 driver 能够适应所有的场景。
- driver 本身在快速发展和迭代。
不过 Docker 官方给出了一个简单的答案：
优先使用 Linux 发行版默认的 storage driver。
Docker 安装时会根据当前系统的配置选择默认的 driver。默认 driver 具有最好的稳定性，因为默认 driver 在发行版上经过了严格的测试。
运行docker info查看CentOS的默认 driver：
bash
[root@docker ~]# docker info
Client: Docker Engine - Community
Version: 26.1.3
Context: default
Debug Mode: false
Plugins:
buildx: Docker Buildx (Docker Inc.)
Version: v0.14.0
Path: /usr/libexec/docker/cli-plugins/docker-buildx
compose: Docker Compose (Docker Inc.)
Version: v2.27.0
Path: /usr/libexec/docker/cli-plugins/docker-compose
Server:
Containers: 2
Running: 0
Paused: 0
Stopped: 2
Images: 16
Server Version: 26.1.3
Storage Driver: overlay2
Backing Filesystem: xfs
Supports d_type: true
Using metacopy: false
Native Overlay Diff: true
userxattr: false
Logging Driver: json-file
Cgroup Driver: cgroupfs
Cgroup Version: 1
Plugins:
Volume: local
Network: bridge host ipvlan macvlan null overlay
Log: awslogs fluentd gcplogs gelf journald json-file local splunk syslog
Swarm: inactive
Runtimes: io.containerd.runc.v2 runc
Default Runtime: runc
Init Binary: docker-init
containerd version: 8b3b7ca2e5ce38e8f31a34f35b2b68ceb8470d89
runc version: v1.1.12-0-g51d5e94
init version: de40ad0
Security Options:
seccomp
Profile: builtin
Kernel Version: 4.18.0-553.6.1.el8.x86_64
Operating System: CentOS Stream 8
OSType: linux
Architecture: x86_64
CPUs: 4
Total Memory: 15.36GiB
Name: docker
ID: fa9330b1-aebb-4889-a2d6-bc7181d443b2
Docker Root Dir: /var/lib/docker
Debug Mode: false
Experimental: false
Insecure Registries:
127.0.0.0/8CentOS Stream 8 用的overlay2，底层文件系统是xfs，各层数据存放在 /var/lib/docker。
对于某些容器，直接将数据放在由 storage driver 维护的层中是很好的选择，比如那些无状态的应用。无状态意味着容器没有需要持久化的数据，随时可以从镜像直接创建。
比如 busybox，它是一个工具箱，我们启动 busybox 是为了执行诸如 wget，ping 之类的命令，不需要保存数据供以后使用，使用完直接退出，容器删除时存放在容器层中的工作数据也一起被删除，这没问题，下次再启动新容器即可。
但对于另一类应用这种方式就不合适了，它们有持久化数据的需求，容器启动时需要加载已有的数据，容器销毁时希望保留产生的新数据，也就是说，这类容器是有状态的。
这就要用到 Docker 的另一种存储机制：Data Volume，下一节我们讨论。
039 Data Volume之bind mount
storage driver 和 data volume 是容器存放数据的两种方式，上一节我们学习了 storage driver，本节开始讨论 Data Volume。
Data Volume 本质上是 Docker Host 文件系统中的目录或文件，能够直接被 mount 到容器的文件系统中。Data Volume 有以下特点：
- Data Volume 是目录或文件，而非没有格式化的磁盘（块设备）。
- 容器可以读写 volume 中的数据。
- volume 数据可以被永久的保存，即使使用它的容器已经销毁。
好，现在我们有数据层（镜像层和容器层）和 volume 都可以用来存放数据，具体使用的时候要怎样选择呢？考虑下面几个场景：
- Database 软件 vs Database 数据
- Web 应用 vs 应用产生的日志
- 数据分析软件 vs input/output 数据
- Apache Server vs 静态 HTML 文件
相信大家会做出这样的选择：
- 前者放在数据层中。因为这部分内容是无状态的，应该作为镜像的一部分。
- 后者放在 Data Volume 中。这是需要持久化的数据，并且应该与镜像分开存放。
还有个大家可能会关心的问题：如何设置 voluem 的容量？
因为 volume 实际上是 docker host 文件系统的一部分，所以 volume 的容量取决于文件系统当前未使用的空间，目前还没有方法设置 volume 的容量。
在具体的使用上，docker 提供了两种类型的 volume：bind mount 和 docker managed volume。
bind mount
bind mount 是将 host 上已存在的目录或文件 mount 到容器。
例如 docker host 上有目录 $HOME/htdocs：
bash
[root@docker ~]# pwd
/root
[root@docker ~]# mkdir htdocs
[root@docker ~]# cd htdocs/
[root@docker htdocs]# touch index.html
[root@docker htdocs]# vim index.html
<html><body><h1>This is a file in host file system !</h1></body></html>
[root@docker htdocs]# cd ..
[root@docker ~]# cat htdocs/index.html
<html><body><h1>This is a file in host file system !</h1></body></html>
[root@docker ~]#通过 -v 将其 mount 到 httpd 容器：
bash
[root@docker ~]# docker run -d -p 80:80 -v ~/htdocs:/usr/local/apache2/htdocs httpd
883f8a22b2be796928d16ad131f6cba922492e325fdadf4275ca9f59eae5ed12-v 的格式为 <host path>:<container path>。/usr/local/apache2/htdocs 就是 apache server 存放静态文件的地方。由于 /usr/local/apache2/htdocs 已经存在，原有数据会被隐藏起来，取而代之的是 host $HOME/htdocs/ 中的数据，这与 linux mount 命令的行为是一致的。
bash
[root@docker ~]# curl 127.0.0.1:80
<html><body><h1>This is a file in host file system !</h1></body></html>curl 显示当前主页确实是 $HOME/htdocs/index.html 中的内容。更新一下，看是否能生效：
bash
[root@docker ~]# echo "updated index page!" > ~/htdocs/index.html
[root@docker ~]#
[root@docker ~]# curl 127.0.0.1:80
updated index page!host 中的修改确实生效了，bind mount 可以让 host 与容器共享数据。这在管理上是非常方便的。
下面我们将容器销毁，看看对 bind mount 有什么影响：
bash
[root@docker ~]# docker stop 883f8a22b2be
883f8a22b2be
[root@docker ~]# docker rm 883f8a22b2be
883f8a22b2be
[root@docker ~]# cat ~/htdocs/index.html
updated index page!
[root@docker ~]#可见，即使容器没有了，bind mount 也还在。这也合理，bind mount 是 host 文件系统中的数据，只是借给容器用用，哪能随便就删了啊。
另外，bind mount 时还可以指定数据的读写权限，默认是可读可写，可指定为只读：
bash
[root@docker ~]# docker run -d -p 80:80 -v ~/htdocs:/usr/local/apache2/htdocs:ro httpd
bf1f526ddde7a7babb29adc091eef039628ba2eb288e6db33c9ccd946cc5d5f1
[root@docker ~]# docker exec -it bf1f526ddde7 bash
root@bf1f526ddde7:/usr/local/apache2# echo "do some changes" > htdocs/index.html
bash: htdocs/index.html: Read-only file systemro 设置了只读权限，在容器中是无法对 bind mount 数据进行修改的。只有 host 有权修改数据，提高了安全性。
除了 bind mount 目录，还可以单独指定一个文件：
bash
# 删除上一个容器不然80端口冲突
[root@docker ~]# docker run -d -p 80:80 -v ~/htdocs/index.html:/usr/local/apache2/htdocs/new_index.html httpd
643e8820e98a17b977a984903ddfa6f37dcae3d705d45b624d0fce5c94fecb0c
[root@docker ~]#
[root@docker ~]# curl 127.0.0.1:80
<html><body><h1>It works!</h1></body></html>
[root@docker ~]#
[root@docker ~]# curl 127.0.0.1:80/new_index.html
updated index page!
[root@docker ~]#使用 bind mount 单个文件的场景是：只需要向容器添加文件，不希望覆盖整个目录。在上面的例子中，我们将 html 文件加到 apache 中，同时也保留了容器原有的数据。
使用单一文件有一点要注意：host 中的源文件必须要存在，不然会当作一个新目录 bind mount 给容器。
mount point 有很多应用场景，比如我们可以将源代码目录 mount 到容器中，在 host 中修改代码就能看到应用的实时效果。再比如将 mysql 容器的数据放在 bind mount 里，这样 host 可以方便地备份和迁移数据。
bind mount 的使用直观高效，易于理解，但它也有不足的地方：bind mount 需要指定 host 文件系统的特定路径，这就限制了容器的可移植性，当需要将容器迁移到其他 host，而该 host 没有要 mount 的数据或者数据不在相同的路径时，操作会失败。
移植性更好的方式是 docker managed volume，下一节我们讨论。
040 Data Volume之docker managed volume
docker managed volume 与 bind mount 在使用上的最大区别是不需要指定 mount 源，指明 mount point 就行了。还是以 httpd 容器为例：
bash
[root@docker ~]# docker run -d -p 80:80 -v /usr/local/apache2/htdocs httpd
c75f36c4bf32e39f2d078d41956be85522c0630cf91498123dcd83ba159ce873我们通过 -v 告诉 docker 需要一个 data volume，并将其 mount 到 /usr/local/apache2/htdocs。那么这个 data volume 具体在哪儿呢？
这个答案可以在容器的配置信息中找到，执行 docker inspect 命令：
bash
[root@docker ~]# docker inspect c75f36c4bf32 #docker inspect后面跟的是容器ID
...
"Mounts": [
{
"Type": "volume",
"Name": "1cc915096121dea197bbbb93fc90e6491d530e0c9e2ace1de07e2a635e569d16",
"Source": "/var/lib/docker/volumes/1cc915096121dea197bbbb93fc90e6491d530e0c9e2ace1de07e2a635e569d16/_data",
"Destination": "/usr/local/apache2/htdocs",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
}
],
... docker inspect 的输出很多，我们感兴趣的是 Mounts 这部分，这里会显示容器当前使用的所有 data volume，包括 bind mount 和 docker managed volume。
Source 就是该 volume 在 host 上的目录。
原来，每当容器申请 mount docker manged volume 时，docker 都会在/var/lib/docker/volumes 下生成一个目录（例子中是 "/var/lib/docker/volumes/1cc915096121dea197bbbb93fc90e6491d530e0c9e2ace1de07e2a635e569d16/_data ），这个目录就是 mount 源。
下面继续研究这个 volume，看看里面有些什么东西：
bash
[root@docker ~]# ls -l /var/lib/docker/volumes/1cc915096121dea197bbbb93fc90e6491d530e0c9e2ace1de07e2a635e569d16/_data
total 4
-rw-r--r-- 1 501 ftp 26 Sep 17 21:08 index.html
[root@docker ~]#
[root@docker ~]# curl 127.0.0.1:80
<html><body><h1>It works!</h1></body></html>volume 的内容跟容器原有 /usr/local/apache2/htdocs 完全一样，这是怎么回事呢？
这是因为：如果 mount point 指向的是已有目录，原有数据会被复制到 volume 中。
但要明确一点：此时的 /usr/local/apache2/htdocs 已经不再是由 storage driver 管理的层数据了，它已经是一个 data volume。我们可以像 bind mount 一样对数据进行操作，例如更新数据：
bash
[root@docker ~]# echo "update volume from host !" > /var/lib/docker/volumes/1cc915096121dea197bbbb93fc90e6491d530e0c9e2ace1de07e2a635e569d16/_data/index.html
[root@docker ~]#
[root@docker ~]# curl 127.0.0.1:80
update volume from host !简单回顾一下 docker managed volume 的创建过程：
- 容器启动时，简单的告诉 docker "我需要一个 volume 存放数据，帮我 mount 到目录 /abc"。
- docker 在 /var/lib/docker/volumes 中生成一个随机目录作为 mount 源。
- 如果 /abc 已经存在，则将数据复制到 mount 源，
- 将 volume mount 到 /abc
除了通过 docker inspect 查看 volume，我们也可以用 docker volume 命令：
bash
[root@docker ~]# docker volume ls
DRIVER VOLUME NAME
local 1cc915096121dea197bbbb93fc90e6491d530e0c9e2ace1de07e2a635e569d16
[root@docker ~]#
[root@docker ~]# docker volume inspect 1cc915096121dea197bbbb93fc90e6491d530e0c9e2ace1de07e2a635e569d16
[
{
"CreatedAt": "2024-09-17T21:04:33+08:00",
"Driver": "local",
"Labels": {
"com.docker.volume.anonymous": ""
},
"Mountpoint": "/var/lib/docker/volumes/1cc915096121dea197bbbb93fc90e6491d530e0c9e2ace1de07e2a635e569d16/_da
"Name": "1cc915096121dea197bbbb93fc90e6491d530e0c9e2ace1de07e2a635e569d16",
"Options": null,
"Scope": "local"
}
]
[root@docker ~]# 目前，docker volume 只能查看 docker managed volume，还看不到 bind mount；同时也无法知道 volume 对应的容器，这些信息还得靠docker inspect。
我们已经学习了两种 data volume 的原理和基本使用方法，下面做个对比：
- 相同点：两者都是 host 文件系统中的某个路径。
- 不同点：
| bind mount | docker managed volume | |
|---|---|---|
| volume 位置 | 可任意指定 | /var/lib/docker/volumes/... |
| 对已有mount point 影响 | 隐藏并替换为 volume | 原有数据复制到 volume |
| 是否支持单个文件 | 支持 | 不支持，只能是目录 |
| 权限控制 | 可设置为只读，默认为读写权限 | 无控制，均为读写权限 |
| 移植性 | 移植性弱，与 host path 绑定 | 移植性强，无需指定 host 目录 |
下节讨论如何通过 data volume 实现容器与 host，容器与容器共享数据。
041 如何共享数据
数据共享是 volume 的关键特性，本节我们详细讨论通过 volume 如何在容器与 host 之间，容器与容器之间共享数据。
容器与 host 共享数据
我们有两种类型的 data volume，它们均可实现在容器与 host 之间共享数据，但方式有所区别。
对于 bind mount 是非常明确的：直接将要共享的目录 mount 到容器。具体请参考前面 httpd 的例子，不再赘述。
docker managed volume 就要麻烦点。由于 volume 位于 host 中的目录，是在容器启动时才生成，所以需要将共享数据拷贝到 volume 中。请看下面的例子：
bash
[root@docker ~]# docker run -d -p 80:80 -v /usr/local/apache2/htdocs httpd
889b9d5309bd12499f8e4ee78a491d9ba7acef5660be00f30cda6569c9974c6f
[root@docker ~]#
[root@docker ~]# curl 127.0.0.1:80
<html><body><h1>It works!</h1></body></html>
[root@docker ~]#
[root@docker ~]# docker cp ~/htdocs/index.html 889b9d5309bd:/usr/local/apache2/htdocs #将host os的/root/htdocs/index.html拷贝到容器中的/usr/local/apache2/htdocs目录下
Successfully copied 2.05kB to 889b9d5309bd:/usr/local/apache2/htdocs
[root@docker ~]#
[root@docker ~]# curl 127.0.0.1:80
updated index page!
[root@docker ~]#docker cp 可以在容器和 host 之间拷贝数据，当然我们也可以直接通过 Linux 的 cp 命令复制到 /var/lib/docker/volumes/xxx。
思考：容器中的文件拷贝到host os如何操作
容器之间共享数据
第一种方法是将共享数据放在 bind mount 中，然后将其 mount 到多个容器。还是以 httpd 为例，不过这次的场景复杂些，我们要创建由三个 httpd 容器组成的 web server 集群，它们使用相同的 html 文件，操作如下：
-
将 $HOME/htdocs mount 到三个 httpd 容器。
bash[root@docker ~]# docker run --name web1 -d -p 80 -v ~/htdocs:/usr/local/apache2/htdocs httpd 994e75ef90a80365d7ea7733c727c3b1d24e5423d59a74185304462b7137d774 [root@docker ~]# [root@docker ~]# docker run --name web2 -d -p 80 -v ~/htdocs:/usr/local/apache2/htdocs httpd 28ff7c72d18b30123ff7e383db211890a0007e48817cdc73e7f50e9f2233eee6 [root@docker ~]# [root@docker ~]# docker run --name web3 -d -p 80 -v ~/htdocs:/usr/local/apache2/htdocs httpd 160d823d985bad0ce7c27a0d301956f3c7ab4e9ca34c5be2601b3374fa30f6f1 [root@docker ~]# -
查看当前主页内容。
bash[root@docker ~]# docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 160d823d985b httpd "httpd-foreground" 13 seconds ago Up 12 seconds 0.0.0.0:32770->80/tcp, :::32770->80/tcp web3 28ff7c72d18b httpd "httpd-foreground" 19 seconds ago Up 18 seconds 0.0.0.0:32769->80/tcp, :::32769->80/tcp web2 994e75ef90a8 httpd "httpd-foreground" 29 seconds ago Up 27 seconds 0.0.0.0:32768->80/tcp, :::32768->80/tcp web1 [root@docker ~]# [root@docker ~]# curl 127.0.0.1:32770 updated index page! [root@docker ~]# curl 127.0.0.1:32769 updated index page! [root@docker ~]# curl 127.0.0.1:32768 updated index page! [root@docker ~]# -
修改 volume 中的主页文件，再次查看并确认所有容器都使用了新的主页。
bash[root@docker ~]# echo "This is a new index page for web cluster" > ~/htdocs/index.html [root@docker ~]# [root@docker ~]# curl 127.0.0.1:32770 This is a new index page for web cluster [root@docker ~]# curl 127.0.0.1:32769 This is a new index page for web cluster [root@docker ~]# curl 127.0.0.1:32768 This is a new index page for web cluster [root@docker ~]#
另一种在容器之间共享数据的方式是使用 volume container，下节讨论。
042 用volume container共享数据
volume container 是专门为其他容器提供 volume 的容器。 它提供的卷可以是 bind mount，也可以是 docker managed volume。下面我们创建一个 volume container：
bash
[root@docker ~]# docker create --name vc_data \
-v ~/htdocs/:/usr/local/apache2/htdocs \
-v /other/userful/tools \
busybox
bb4a33bf34aa7817ea752db83079aff15a5dfd77c23363f2e8dd3096d1cb910f我们将容器命名为 vc_data（vc 是 volume container 的缩写）。注意这里执行的是 docker create 命令，这是因为 volume container 的作用只是提供数据，它本身不需要处于运行状态。容器 mount 了两个 volume：
- bind mount，存放 web server 的静态文件。
- docker managed volume，存放一些实用工具（当然现在是空的，这里只是做个示例）。
通过 docker inspect 可以查看到这两个 volume。
bash
[root@docker ~]# docker inspect vc_data
...
"Mounts": [
{
"Type": "volume",
"Name": "4500300655eb8e32a5d88174395a61ea394e17266fbde60f224d815a7a9557e0",
"Source": "/var/lib/docker/volumes/4500300655eb8e32a5d88174395a61ea394e17266fbde60f224d815a7a9557e0/_data",
"Destination": "/other/userful/tools",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
},
{
"Type": "bind",
"Source": "/root/htdocs",
"Destination": "/usr/local/apache2/htdocs",
"Mode": "",
"RW": true,
"Propagation": "rprivate"
}
],
...其他容器可以通过 --volumes-from 使用 vc_data 这个 volume container：
bash
[root@docker ~]# docker run --name web1 -d -p 80 --volumes-from vc_data httpd
362f039b562e4bf0020c38839a69bfd62733f27fda5481eb5b58178f41318ffe
[root@docker ~]#
[root@docker ~]# docker run --name web2 -d -p 80 --volumes-from vc_data httpd
217c1a243bb9a1f32ccae9ae2792e3720263d36402bbac58f43cfb068bc21e66
[root@docker ~]#
[root@docker ~]# docker run --name web3 -d -p 80 --volumes-from vc_data httpd
ce00b5fa458fc1af01e82ce8b43e8c072c858a669c1298add8053cbc7ac9f49b
[root@docker ~]#三个 httpd 容器都使用了 vc_data，看看它们现在都有哪些 volume，以 web1 为例：
bash
[root@docker ~]# docker inspect web1
...
"Mounts": [
{
"Type": "bind",
"Source": "/root/htdocs",
"Destination": "/usr/local/apache2/htdocs",
"Mode": "",
"RW": true,
"Propagation": "rprivate"
},
{
"Type": "volume",
"Name": "4500300655eb8e32a5d88174395a61ea394e17266fbde60f224d815a7a9557e0",
"Source": "/var/lib/docker/volumes/4500300655eb8e32a5d88174395a61ea394e17266fbde60f224d815a7a9557e0/_data",
"Destination": "/other/userful/tools",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
}
],
...web1 容器使用的就是 vc_data 的 volume，而且连 mount point 都是一样的。验证一下数据共享的效果：
bash
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ce00b5fa458f httpd "httpd-foreground" 2 minutes ago Up 2 minutes 0.0.0.0:32773->80/tcp, :::32773->80/tcp web3
217c1a243bb9 httpd "httpd-foreground" 2 minutes ago Up 2 minutes 0.0.0.0:32772->80/tcp, :::32772->80/tcp web2
362f039b562e httpd "httpd-foreground" 2 minutes ago Up 2 minutes 0.0.0.0:32771->80/tcp, :::32771->80/tcp web1
[root@docker ~]#
[root@docker ~]# echo "This content is from a volume container!" > ~/htdocs/index.html
[root@docker ~]#
[root@docker ~]# curl 127.0.0.1:32773
This content is from a volume container!
[root@docker ~]# curl 127.0.0.1:32772
This content is from a volume container!
[root@docker ~]# curl 127.0.0.1:32771
This content is from a volume container!可见，三个容器已经成功共享了 volume container 中的 volume。
下面我们讨论一下 volume container 的特点：
- 与 bind mount 相比，不必为每一个容器指定 host path，所有 path 都在 volume container 中定义好了，容器只需与 volume container 关联，实现了容器与 host 的解耦。
- 使用 volume container 的容器其 mount point 是一致的，有利于配置的规范和标准化，但也带来一定的局限，使用时需要综合考虑。
另一种在容器之间共享数据的方式是 data-packed volume container，下一节讨论。
043 data-packed volume container
在上一节的例子中 volume container 的数据归根到底还是在 host 里，有没有办法将数据完全放到 volume container 中，同时又能与其他容器共享呢？
当然可以，通常我们称这种容器为 data-packed volume container。其原理是将数据打包到镜像中，然后通过 docker managed volume 共享。
我们用下面的 Dockfile 构建镜像：
dockerfile
[root@docker ~]# vim Dockerfile
FROM busybox:latest
ADD htdocs /usr/local/apache2/htdocs
VOLUME /usr/local/apache2/htdocsADD 将静态文件添加到容器目录 /usr/local/apache2/htdocs。
VOLUME 的作用与 -v 等效，用来创建 docker managed volume，mount point 为 /usr/local/apache2/htdocs，因为这个目录就是 ADD 添加的目录，所以会将已有数据拷贝到 volume 中。
修改文本内容
bash
[root@docker ~]# echo "This content is from a data packed volume container!" > htdocs/index.htmlbuild 新镜像 datapacked：
bash
[root@docker ~]# docker build -t datapacked .
用新镜像创建 data-packed volume container：
bash
[root@docker ~]# docker create --name vc_data datapacked
55dc035deeb31907830ea45f7af5e209c7e48078d59732798c529e7445d2a196因为在 Dockerfile 中已经使用了 VOLUME 指令，这里就不需要指定 volume 的 mount point 了。启动 httpd 容器并使用 data-packed volume container：
bash
[root@docker ~]# docker run -d -p 80:80 --volumes-from vc_data httpd
98db78fc661441ec7ce0a2b76d62675fccf3389b7768cc9744b852645323c33b
[root@docker ~]#
[root@docker ~]# curl 127.0.0.1:80
This content is from a data packed volume container!容器能够正确读取 volume 中的数据。data-packed volume container 是自包含的，不依赖 host 提供数据，具有很强的移植性，非常适合 只使用 静态数据的场景，比如应用的配置信息、web server 的静态文件等。
容器数据共享就讨论到这里，下一节我们学习如何对 data volume 的生命周期进行管理。
044 volume生命周期管理
Data Volume 中存放的是重要的应用数据，如何管理 volume 对应用至关重要。前面我们主要关注的是 volume 的创建、共享和使用，本节将讨论如何备份、恢复、迁移和销毁 volume。
备份
因为 volume 实际上是 host 文件系统中的目录和文件，所以 volume 的备份实际上是对文件系统的备份。
还记得前面我们是如何搭建本地 Registry 的吗？
bash
[root@docker ~]# docker run -d -p 5000:5000 -v /myregistry:/var/lib/registry registry:2
Unable to find image 'registry:2' locally
2: Pulling from library/registry
1cc3d825d8b2: Pull complete
85ab09421e5a: Pull complete
40960af72c1c: Pull complete
e7bb1dbb377e: Pull complete
a538cc9b1ae3: Pull complete
Digest: sha256:ac0192b549007e22998eb74e8d8488dcfe70f1489520c3b144a6047ac5efbe90
Status: Downloaded newer image for registry:2
a8214201171f28a13803c647ef84acdc982465c230cb5c6a034bd05574948408
[root@docker ~]#所有的本地镜像都存在 host 的 /myregistry 目录中，我们要做的就是定期备份这个目录。
恢复
volume 的恢复也很简单，如果数据损坏了，直接用之前备份的数据拷贝到 /myregistry 就可以了。
迁移
如果我们想使用更新版本的 Registry，这就涉及到数据迁移，方法是：
-
docker stop当前 Registry 容器。 -
启动新版本容器并 mount 原有 volume。
docker run -d -p 5000:5000 -v /myregistry:/var/lib/registry registry:latest
当然，在启用新容器前要确保新版本的默认数据路径是否发生变化。
销毁
可以删除不再需要的 volume，但一定要确保知道自己正在做什么，volume 删除后数据是找不回来的。
docker 不会销毁 bind mount，删除数据的工作只能由 host 负责。对于 docker managed volume，在执行 docker rm 删除容器时可以带上 -v 参数，docker 会将容器使用到的 volume 一并删除，但前提是没有其他容器 mount 该 volume，目的是保护数据，非常合理。
如果删除容器时没有带 -v 呢？这样就会产生孤儿 volume，好在 docker 提供了 volume 子命令可以对 docker managed volume 进行维护。请看下面的例子：
bash
[root@docker ~]# docker volume ls
DRIVER VOLUME NAME
[root@docker ~]#
[root@docker ~]# docker run --name bbox -v /test/data busybox
[root@docker ~]#
[root@docker ~]# docker volume ls
DRIVER VOLUME NAME
local 8645b8e2edb91820799e6e8807d8b3476f1c5cec40beb14240b0e5143050e5e1容器 bbox 使用的 docker managed volume 可以通过 docker volume ls 查看到。
删除 bbox：
bash
[root@docker ~]# docker rm bbox
bbox
[root@docker ~]# docker volume ls
DRIVER VOLUME NAME
local 8645b8e2edb91820799e6e8807d8b3476f1c5cec40beb14240b0e5143050e5e1
[root@docker ~]#因为没有使用 -v，volume 遗留了下来。对于这样的孤儿 volume，可以用 docker volume rm 删除：
bash
[root@docker ~]# docker volume rm 8645b8e2edb91820799e6e8807d8b3476f1c5cec40beb14240b0e5143050e5e1
8645b8e2edb91820799e6e8807d8b3476f1c5cec40beb14240b0e5143050e5e1
[root@docker ~]#
[root@docker ~]# docker volume ls
DRIVER VOLUME NAME
[root@docker ~]#如果想批量删除孤儿 volume，可以执行：
docker volume rm $(docker volume ls -q)
小结
本章我们学习了以下内容：
- docker 为容器提供了两种存储资源：数据层和 Data Volume。
- 数据层包括镜像层和容器层，由 storage driver 管理。
- Data Volume 有两种类型：bind mount 和 docker managed volume。
- bind mount 可实现容器与 host 之间，容器与容器之间共享数据。
- volume container 是一种具有更好移植性的容器间数据共享方案，特别是 data-packed volume container。
- 最后我们学习了如何备份、恢复、迁移和销毁 Data Volume。
实战：安装mysql
docker hub上查找mysql镜像
bash
[root@docker ~]# docker search mysql从华为云加速器拉取mysql镜像到本地标签为5.7
bash
[root@docker ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
20e4dcae4c69: Pull complete
1c56c3d4ce74: Pull complete
e9f03a1c24ce: Pull complete
68c3898c2015: Pull complete
6b95a940e7b6: Pull complete
90986bb8de6e: Pull complete
ae71319cb779: Pull complete
ffc89e9dfd88: Pull complete
43d05e938198: Pull complete
064b2d298fba: Pull complete
df9a4d85569b: Pull complete
Digest: sha256:4bc6bc963e6d8443453676cae56536f4b8156d78bae03c0145cbe47c2aad73bb
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7使用mysql镜像
简单版
bash
[root@docker ~]# docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
cf4065b04c9d68bb02ef8ccb74b8b02f357f588680328556afcf008dd69c7138
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cf4065b04c9d mysql:5.7 "docker-entrypoint.s..." 38 seconds ago Up 36 seconds 0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp elated_gauss
[root@docker ~]# docker exec -it cf4065b04c9d bash
bash-4.2# mysql -uroot -p123456
mysql: [Warning] Using a password on the command line interface can be insecure.
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.44 MySQL Community Server (GPL)
Copyright (c) 2000, 2023, Oracle and/or its affiliates.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql>建库建表插入数据
mysql
mysql> CREATE DATABASE db01; #创建数据库叫db01
Query OK, 1 row affected (0.00 sec)
mysql> USE db01; #使用db01;
Database changed
mysql> CREATE TABLE tablea(id int,name varchar(20));
Query OK, 0 rows affected (0.04 sec)
mysql> INSERT INTO tablea VALUES(1,'dcr');
Query OK, 1 row affected (0.14 sec)
mysql> SELECT * FROM tablea;
+------+------+
| id | name |
+------+------+
| 1 |dcr |
+------+------+
1 row in set (0.00 sec)
mysql>外部windows连接运行在docker上的mysql容器实例服务
安装navicat160_premium_cs_x64.exe,一直下一步直到安装完成
双击桌面图标打开
插入中文试试
报错了
为什么报错？
docker上默认字符集不支持中文
mysql
mysql> SHOW VARIABLES LIKE 'character%';
+--------------------------+----------------------------+
| Variable_name | Value |
+--------------------------+----------------------------+
| character_set_client | latin1 |
| character_set_connection | latin1 |
| character_set_database | latin1 |
| character_set_filesystem | binary |
| character_set_results | latin1 |
| character_set_server | latin1 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.00 sec)删除容器后，里面的mysql数据在不在？
bash
# 删除mysql容器
[root@docker ~]# docker rm -f cf4065b04c9d容器实例删除，你还有什么？删库到跑路？
再用同样的方式创建一个mysql，数据还在么?
bash
[root@docker ~]# docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
1e1a206582f2c7cf79a3c764b2c441b49d752146d87b09681f6e84dba1232361
实战版
新建mysql实例
bash
[root@docker ~]# docker run -d -p 3306:3306 --privileged=true -v /dcr/mysql/log:/var/log/mysql -v /dcr/mysql/data:/var/lib/mysql -v /dcr/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql mysql:5.7
ff28918675ccf77947aba0b9602d40edfee1a4e9ff3122288d4c84d7c80e3f49新建my.cnf，通过容器卷同步给mysql容器实例
bash
[root@docker ~]# cd /dcr/mysql/conf
[root@docker conf]# ls
[root@docker conf]# vim my.cnf #实现mysql支持中文
[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8
[root@docker conf]#重新启动mysql容器实例再重新进入并查看字符编码
bash
[root@docker conf]# docker restart mysql
mysql
[root@docker conf]# docker exec -it mysql bash
bash-4.2# mysql -uroot -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.44 MySQL Community Server (GPL)
Copyright (c) 2000, 2023, Oracle and/or its affiliates.
Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
mysql> SHOW VARIABLES LIKE 'character%';
+--------------------------+----------------------------+
| Variable_name | Value |
+--------------------------+----------------------------+
| character_set_client | utf8 |
| character_set_connection | utf8 |
| character_set_database | utf8 |
| character_set_filesystem | binary |
| character_set_results | utf8 |
| character_set_server | utf8 |
| character_set_system | utf8 |
| character_sets_dir | /usr/share/mysql/charsets/ |
+--------------------------+----------------------------+
8 rows in set (0.01 sec)
mysql> CREATE DATABASE db01; #创建数据库叫db01
Query OK, 1 row affected (0.00 sec)
mysql> USE db01; #使用db01;
Database changed
mysql> CREATE TABLE tablea(id int,name varchar(20));
Query OK, 0 rows affected (0.04 sec)
mysql> INSERT INTO tablea VALUES(1,'dcr');
Query OK, 1 row affected (0.14 sec)
mysql> SELECT * FROM tablea;
+------+------+
| id | name |
+------+------+
| 1 | dcr |
+------+------+
1 row in set (0.00 sec)
mysql>在新建库新建表再插入中文测试
不报错了！
假如当前容器实例删除，再重新来一次，之前创建的db01实例还有吗？？赶紧动起来尝试一下吧！！！
再次删库跑路！！！
bash
[root@docker ~]# docker rm -f ff28918675cc重新创建容器，看看数据还在不在
bash
[root@docker ~]# docker run -d -p 3306:3306 --privileged=true -v /dcr/mysql/log:/var/log/mysql -v /dcr/mysql/data:/var/lib/mysql -v /dcr/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql mysql:5.7
507cd722fc40b75f5eb0202c09eb9276a7046b64797864eb5bba15144e01f661发现数据还在
第7章 容器监控
Docker自带的监控子命令
当Docker部署规模逐步变大后，可视化监控容器环境的性能和健康状态将会变得越来越重要。
ps
docker ps 是我们早已熟悉的命令了，方便我们查看当前运行的容器。前面已经有大量示例，这里就不赘述了。
bash
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
9f8bc2c3a5c7 nginx "/docker-entrypoint...." 3 seconds ago Up 2 seconds 80/tcp sad_faraday
1e0b0631cf70 httpd:centos "/bin/sh -c '/usr/sb..." 23 minutes ago Up 23 minutes 0.0.0.0:80->80/tcp, :::80->80/tcp myweb
4b78f371fc06 centos:ssh "/usr/sbin/sshd -D" 32 minutes ago Up 32 minutes 0.0.0.0:2022->22/tcp, :::2022->22/tcp sshtesttop
查看容器的进程
bash
[root@docker ~]# docker top --help
Usage: docker top CONTAINER [ps OPTIONS]
Display the running processes of a container
Aliases:
docker container top, docker top示例：
bash
[root@docker ~]# docker top sshtest #sshtest是容器名
UID PID PPID C STIME TTY TIME CMD
root 5220 5198 0 21:31 ? 00:00:00 /usr/sbin/sshd -D命令后面还可以跟上 Linux 操作系统 ps 命令的参数显示特定的信息，比如 -au。
bash
[root@docker ~]# docker top sshtest -au
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 5220 0.0 0.0 76532 7080 ? Ss 21:31 0:00 /usr/sbin/sshd -Dstats
列出容器资源使用率
bash
[root@docker ~]# docker stats --help
Usage: docker stats [OPTIONS] [CONTAINER...]
Display a live stream of container(s) resource usage statistics
Aliases:
docker container stats, docker stats
Options:
-a, --all Show all containers (default shows just running)
--format string Format output using a custom template:
'table': Print output in table format with column headers (default)
'table TEMPLATE': Print output in table format using the given Go template
'json': Print in JSON format
'TEMPLATE': Print output using the given Go template.
Refer to https://docs.docker.com/go/formatting/ for more information about formatting output with templates
--no-stream Disable streaming stats and only pull the first result
--no-trunc Do not truncate output示例：
bash
[root@docker ~]# docker stats
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
9f8bc2c3a5c7 sad_faraday 0.00% 5.141MiB / 15.36GiB 0.03% 866B / 0B 8.19kB / 26.6kB 5
1e0b0631cf70 myweb 0.06% 38.39MiB / 15.36GiB 0.24% 1.64kB / 609B 0B / 0B 213
4b78f371fc06 sshtest 0.00% 2.258MiB / 15.36GiB 0.01% 9.7kB / 7.99kB 8.19kB / 23.6kB 1默认会显示一个实时变化的列表，展示每个容器的 CPU 使用率，内存使用量和可用量，网络和磁盘的 IO 数据。
注意：容器启动时如果没有特别指定内存 limit，stats 命令会显示 host 的内存总量，但这并不意味着每个 container 都能使用到这么多的内存。
cAdvisor
cAdvisor 是 google 开发的容器监控工具。
bash
[root@docker ~]# docker run \
--volume=/:/rootfs:ro \
--volume=/var/run:/var/run:rw \
--volume=/sys:/sys:ro \
--volume=/var/lib/docker/:/var/lib/docker:ro \
--publish=8080:8080 \
--detach=true \
--name=cadvisor \
google/cadvisor:latest也可以使用镜像hub.c.163.com/xbingo/cadvisor:latest。
通过 http://[Host_IP]:8080 访问 cAdvisor。首次打开比较慢，系统需要收集数据并绘制图表。
点击Docker Containers进去看容器具体信息
总结：
- 缺点：操作界面略显简陋，而且需要在不同页面之间跳转，并且只能监控一个 host。
- 优点：可以将监控到的数据导出给第三方工具，由这些工具进一步加工处理。
结论：我们把 cAdvisor 定位为一个监控数据收集器，并导出数据给第三方工具，而非展示数据。
第8章 容器日志
高效的监控和日志管理对保持生产系统持续稳定地运行以及排查问题至关重要。
在微服务架构中，由于容器的数量众多以及快速变化的特性使得记录日志和监控变得越来越重要。考虑到容器短暂和不固定的生命周期，当我们需要 debug 问题时有些容器可能已经不存在了。因此，一套集中式的日志管理系统是生产环境中不可或缺的组成部分。
Docker logs
对于一个运行的容器，Docker 会将日志发送到 容器标准输出设备（STDOUT）和标准错误设备（STDERR），STDOUT 和 STDERR 实际上就是容器的控制台终端。
举个例子，用下面的命令运行 httpd 容器：
bash
[root@docker ~]# docker run -p 80:80 httpd
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
[Tue Oct 08 14:28:10.312876 2024] [mpm_event:notice] [pid 1:tid 1] AH00489: Apache/2.4.62 (Unix) configured -- resuming normal operations
[Tue Oct 08 14:28:10.316058 2024] [core:notice] [pid 1:tid 1] AH00094: Command line: 'httpd -D FOREGROUND'我们在启动日志的时候没有用 -d 参数，httpd 容器以前台方式启动，日志会直接打印在当前的终端窗口。
如果加上 -d 参数以后台方式运行容器，我们就看不到输出的日志了。
bash
[root@docker ~]# docker run -d -p 80:80 httpd
a8286845e6f8afc09fdcdf0b94248239963e3ad04495e927a68a2148814c65fd这种情况下如果要查看容器的日志，有两种方法：
- attach 到该容器。
- 用
docker logs命令查看日志。
先来看 attach 的方法。运行 docker attach 命令。
bash
[root@docker ~]# docker attach a8286845e6f8attach 到了 httpd 容器，但并没有任何输出，这是因为当前没有新的日志信息。
为了产生一条新的日志，可以在 host 的另一个命令行终端执行 curl localhost。
终端B：
bash
[root@docker ~]# curl localhost
<html><body><h1>It works!</h1></body></html>
[root@docker ~]# curl localhost
<html><body><h1>It works!</h1></body></html>这时，attach 的终端就会打印出新的日志。
终端A:
bash
[root@docker ~]# docker attach a8286845e6f8
172.17.0.1 - - [08/Oct/2024:14:30:24 +0000] "GET / HTTP/1.1" 200 45
172.17.0.1 - - [08/Oct/2024:14:30:25 +0000] "GET / HTTP/1.1" 200 45attach 的方法在实际使用中不太方便，因为：
- 只能看到 attach 之后的日志，以前的日志不可见。
- 退出 attach 状态比较麻烦（Ctrl+p 然后 Ctrl+q 组合键），一不小心很容器将容器杀掉（比如按下 Ctrl+C）。
查看容器日志推荐的方法是用 docker logs 命令。
bash
[root@docker ~]# docker logs a8286845e6f8
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
[Tue Oct 08 14:28:33.168712 2024] [mpm_event:notice] [pid 1:tid 1] AH00489: Apache/2.4.62 (Unix) configured -- resuming normal operations
[Tue Oct 08 14:28:33.168801 2024] [core:notice] [pid 1:tid 1] AH00094: Command line: 'httpd -D FOREGROUND'
[Tue Oct 08 14:29:37.160729 2024] [mpm_event:notice] [pid 1:tid 1] AH00491: caught SIGTERM, shutting down
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
[Tue Oct 08 14:30:08.379226 2024] [mpm_event:notice] [pid 1:tid 1] AH00489: Apache/2.4.62 (Unix) configured -- resuming normal operations
[Tue Oct 08 14:30:08.379375 2024] [core:notice] [pid 1:tid 1] AH00094: Command line: 'httpd -D FOREGROUND'
172.17.0.1 - - [08/Oct/2024:14:30:24 +0000] "GET / HTTP/1.1" 200 45
172.17.0.1 - - [08/Oct/2024:14:30:25 +0000] "GET / HTTP/1.1" 200 45
[Tue Oct 08 14:31:35.664386 2024] [mpm_event:notice] [pid 1:tid 1] AH00491: caught SIGTERM, shutting down
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
AH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 172.17.0.3. Set the 'ServerName' directive globally to suppress this message
[Tue Oct 08 14:31:41.995159 2024] [mpm_event:notice] [pid 1:tid 1] AH00489: Apache/2.4.62 (Unix) configured -- resuming normal operations
[Tue Oct 08 14:31:41.995339 2024] [core:notice] [pid 1:tid 1] AH00094: Command line: 'httpd -D FOREGROUND'
172.17.0.1 - - [08/Oct/2024:14:30:24 +0000] "GET / HTTP/1.1" 200 45
172.17.0.1 - - [08/Oct/2024:14:30:25 +0000] "GET / HTTP/1.1" 200 45docker logs 能够打印出自容器启动以来完整的日志，并且 -f 参数可以继续打印出新产生的日志，效果上与 Linux 命令 tail -f 一样。
第9章 Docker-compose
我们知道使用一个 Dockerfile 模板文件，可以让用户很方便的定义一个单独的应用容器。然而，在日常工作中，经常会碰到需要多个容器相互配合来完成某项任务的情况。例如要实现一个 Web 项目，除了 Web 服务容器本身，往往还需要再加上后端的数据库服务容器，甚至还包括负载均衡容器等。如果每个容器都要按顺序手动启停，那么维护工作量将会很大，而且工作效率也很低。
Docker Compose 可以轻松、高效地管理容器，它是一个用于定义和运行多容器的管理工具。
它通过一个单独的 docker-compose.yml 模板文件（YAML 格式）定义一组相关联资源集。
Compose 中有两个重要的概念：
- 服务 (
service)：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。 - 项目 (
project)：由一组关联的应用容器组成的一个完整业务单元，在docker-compose.yml文件中定义。
Compose 的默认管理对象是项目，通过子命令对项目中的一组容器进行便捷地生命周期管理。
Compose 项目由 Python 编写(后用Go语言重写)，实现上调用了 Docker 服务提供的 API 来对容器进行管理。因此，只要所操作的平台支持 Docker API，就可以在其上利用 Compose 来进行编排管理。
命令说明
bash
[root@docker ~]# docker compose -h
Flag shorthand -h has been deprecated, please use --help
Usage: docker compose [OPTIONS] COMMAND
Define and run multi-container applications with Docker
Options:
--all-resources Include all resources, even those not used by services
--ansi string Control when to print ANSI control characters ("never"|"always"|"auto") (default "auto")
--compatibility Run compose in backward compatibility mode
--dry-run Execute command in dry run mode
--env-file stringArray Specify an alternate environment file
-f, --file stringArray Compose configuration files
--parallel int Control max parallelism, -1 for unlimited (default -1)
--profile stringArray Specify a profile to enable
--progress string Set type of progress output (auto, tty, plain, quiet) (default "auto")
--project-directory string Specify an alternate working directory
(default: the path of the, first specified, Compose file)
-p, --project-name string Project name
Commands:
attach Attach local standard input, output, and error streams to a service's running container
build Build or rebuild services
config Parse, resolve and render compose file in canonical format
cp Copy files/folders between a service container and the local filesystem
create Creates containers for a service
down Stop and remove containers, networks
events Receive real time events from containers
exec Execute a command in a running container
images List images used by the created containers
kill Force stop service containers
logs View output from containers
ls List running compose projects
pause Pause services
port Print the public port for a port binding
ps List containers
pull Pull service images
push Push service images
restart Restart service containers
rm Removes stopped service containers
run Run a one-off command on a service
scale Scale services
start Start services
stats Display a live stream of container(s) resource usage statistics
stop Stop services
top Display the running processes
unpause Unpause services
up Create and start containers
version Show the Docker Compose version information
wait Block until the first service container stops
watch Watch build context for service and rebuild/refresh containers when files are updated
Run 'docker compose COMMAND --help' for more information on a command.version
bash
[root@docker ~]# docker compose version
Docker Compose version v2.27.0Compose 模板
模板文件是使用 Compose 的核心，涉及到的指令关键字也比较多。但大家不用担心，这里面大部分指令跟 docker run 相关参数的含义都是类似的。
默认的模板文件名称为 docker-compose.yml，格式为 YAML 格式。
模板文件结构
- version：用来定义模板文件的版本，不同版本的模板，格式也不一样。
- 资源列表：用来定义资源清单，包括service、secret、network、volume等。
- 注释行：
#开头的注释行。
示例：使用版本2模板，定义一个使用httpd镜像的services。
version: "2"
services:
webapp:
image: httpd详细结构参考官方
Compose文档
- User guide
- Installing Compose
- Compose file versions and upgrading
- Sample apps with Compose
- Command line reference
实战-Wordpress
回顾一下如果用docker run改如何操作：
bash
[root@docker ~]# docker run -tid --name db --restart always -v /db:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=huawei -e MYSQL_DATABASE=wordpress mysql
d3fa1d9e6ecc285427b38bca95130cade90ca69ee9487825db92b3bc8af4c995
[root@docker ~]# docker run -tid --name blog -v /web:/var/www/html -p 80:80 --link db -e WORDPRESS_DB_HOST=db -e WORDPRESS_DB_USER=root -e WORDPRESS_DB_PASSWORD=huawei -e WORDPRESS_DB_NAME=wordpress wordpress
b5b80bd69f57bff576415f2e449a23fe6cb37be353f9b4b69d24d60a2fb9a6e1
[root@docker ~]#
[root@docker ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
b5b80bd69f57 wordpress "docker-entrypoint.s..." 13 seconds ago Up 12 seconds 0.0.0.0:80->80/tcp, :::80->80/tcp blog
d3fa1d9e6ecc mysql "docker-entrypoint.s..." 26 seconds ago Up 25 seconds 3306/tcp, 33060/tcp db
MYSQL_DATABASE=wordpress测试效果：
通过docker compose来统一管理这两个容器呢？
假设新建一个名为 wordpress 的文件夹，然后进入这个文件夹，创建 docker-compose.yml 文件
bash
# 删除之前的环境
[root@docker ~]# docker rm -f $(docker ps -aq)
# 通过docker compose实现多个容器一起启动
[root@docker ~]# mkdir wordpress
[root@docker ~]# cd wordpress/
[root@docker wordpress]# vim docker-compose.yml
services:
blog: #服务名字，相当于docker run的时候指定的一个名称
image: wordpress:latest #必选，镜像的名字
restart: always
links:
- db
ports: #可选，等价于 docker run 里的 -p 选项指定端口映射
- "80:80"
environment: #可选，等价于 docker run 里的 --env 选项设置环境变量
- WORDPRESS_DB_HOST=db
- WORDPRESS_DB_USER=root
- WORDPRESS_DB_PASSWORD=huawei
- WORDPRESS_DB_NAME=wordpress
db:
image: mysql:latest
restart: always
environment:
- MYSQL_ROOT_PASSWORD=huawei
- MYSQL_DATABASE=wordpress
[root@docker wordpress]# docker compose config -q #检测语法后端运行
bash
[root@docker wordpress]# docker compose up -d
[+] Running 3/3
✔ Network wordpress_default Created 0.0s
✔ Container wordpress-db-1 Started 0.3s
✔ Container wordpress-blog-1 Started 0.6s 查看现象
bash
[root@docker wordpress]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
85b438b2ff89 wordpress:latest "docker-entrypoint.s..." About a minute ago Up About a minute 0.0.0.0:80->80/tcp, :::80->80/tcp wordpress-blog-1
3c340ed1e299 mysql:latest "docker-entrypoint.s..." About a minute ago Up About a minute 3306/tcp, 33060/tcp wordpress-db-1
第10章 docker图形界面管理
DockerUI 容器管理器的安装与使用
简介：
DockerUI是一个易用且轻量化的 Docker 管理工具，通过 Web 界面的操作，更方便对于 Docker 指令不熟悉的用户更容易操作 Docker 。
功能：
- Docker主机管理：数据卷管理，镜像管理，容器管理，构建管理，仓库配置管理，网络配置管理
- Docker Swarm集群管理：集群概要信息，节点管理，Service管理，任务管理，密码管理，配置管理
镜像：
我今天分享的这个镜像是来自于这位大佬@joinsunsoft 的，他发布在Docker Hub的镜像地址为：https://hub.docker.com/r/joinsunsoft/docker.ui
安装
启动容器并映射8999端口：
bash
[root@docker ~]# docker run -d --name docker.ui --restart always -v /var/run/docker.sock:/var/run/docker.sock -p 8999:8999 joinsunsoft/docker.ui
7af59b5074732e4bd7cb9ca532379ddc35f52cbbc6aa653bda67954e56ce8d3e启动效果
你可以访问：http://192.168.108.30:8999
默认用户名密码：ginghan /123456
DockerUI的主界面（概览），它展示的信息还是很多的，除了容器相关，还有资源占用情况等信息。不得不说还是国人更懂国人，UI界面还是很漂亮的对吧~
Docker 图形化界面管理工具 Portainer
Portainer 是一个 Docker 图形化管理工具，可以通过 Web UI 轻松的管理容器、镜像、网络、卷。同时上手难度也更大一些
Portainer 分为社区版和商业版，本文安装的是社区版（Portainer CE），该版本免费，比较适合个人用户使用
安装
1.创建存储卷
bash
[root@docker ~]# docker volume create portainer_data
portainer_data2.通过docker安装Portainer
bash
[root@docker ~]# docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:latest
bd0967eedcae7fddbe5217bafcac7761c6a2d6f430e4b80bf5f4a9551567a8289443 端口默认会启用 SSL，如果需要直接通过 http 访问，需要加上 -p 9000:9000 访问 9000 端口
这里，
-v /var/run/docker.sock:/var/run/docker.sock参数使得Portainer能够访问Docker守护进程，从而能够管理容器。-v portainer_data:/data参数则用于持久化Portainer的数据。
访问
通过 http://ip:9000 或者 https://ip:9443 访问 Portainer，首次访问需要创建管理员账号
创建用户及密码
完成登录后，管理本机直接点击 Get Started
进入主界面可以看到 local，点击 Live connect
连接到该机器后，就可以看到 Docker 相关状态并且可以对其进行管理
综合实验
构建WordPress
通过WordPress和mysql镜像构建WordPress应用。
下载镜像：
bash
[root@docker ~]# docker pull mysql
[root@docker ~]# docker pull wordpress创建mysql容器，并创建wordpress数据库：
bash
[root@docker ~]# docker run -d -p 3306:3306 \
-v /mysql:/var/lib/mysql:z \
--name mysql \
-e MYSQL_ROOT_PASSWORD=huawei \
-e MYSQL_DATABASE=wordpress \
mysql
6dd12147c9156055042587950e23d543cca47617c3a82bef14c58ffe90580301
[root@docker ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
6dd12147c915 mysql "docker-entrypoint.s..." 15 seconds ago Up 14 seconds 0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp mysql创建WordPress容器：
bash
[root@docker ~]# docker inspect mysql|grep IPAddress
"SecondaryIPAddresses": null,
"IPAddress": "172.17.0.2",
"IPAddress": "172.17.0.2",
[root@docker ~]# docker run -d -p 80:80 -v /www:/var/www/html:z \
--name wordpress \
-e WORDPRESS_DB_HOST=172.17.0.2 \
-e WORDPRESS_DB_USER=root \
-e WORDPRESS_DB_PASSWORD=huawei \
-e WORDPRESS_DB_NAME=wordpress \
wordpress
63fa3a61f9bae2a03f3c0c21b574cca75c9a58c5c2645a6f702179c63f5f06eb说明：
-e WORDPRESS_DB_HOST=...(defaults to the IP and port of the linkedmysqlcontainer)
-e WORDPRESS_DB_USER=...(defaults to "root")
-e WORDPRESS_DB_PASSWORD=...(defaults to the value of theMYSQL_ROOT_PASSWORDenvironment variable from the linkedmysqlcontainer)
-e WORDPRESS_DB_NAME=...(defaults to "wordpress")
验证：浏览器打开http://192.168.108.30，配置WordPress：
Docker环境下部署Ghost开源内容管理系统
一、Ghost介绍
1.1 Ghost简介
Ghost是一款用于博客、出版物和内容网站的免费且开源的CMS（内容管理系统），它是完全基于JavaScript编写的。Ghost的主要特点是简单易用、高度可扩展、精美的设计和优秀的性能。
1.2 Ghost特点
简单易用：Ghost的用户界面非常简单和直观，因此非常易于使用。它提供了一个简单的写作体验，让您专注于写作。
可扩展：Ghost提供了一个强大的API，使得开发者可以轻松地扩展其功能，并将其与其他应用程序集成。
设计优美：Ghost的设计非常美观和优雅，它为您提供了多种主题和自定义选项来满足您的需求。
性能优越：Ghost的性能非常好，因为它是基于Node.js构建的，使用了非阻塞I/O，可以处理大量的请求和并发连接。
1.3 Ghost使用场景
Ghost适用于各种类型的博客、出版物和内容网站，包括但不限于以下场景。
个人博客：Ghost提供简单易用的界面，使个人博主能够轻松创建和管理自己的博客，并分享自己的想法、故事和经验。
新闻网站：Ghost的高度可扩展性使其成为构建新闻网站的理想选择。它具有良好的性能，可以处理大量的文章和高流量的访问。
音乐/艺术家网站：Ghost的精美设计和优秀的性能使其非常适合用于展示音乐家、艺术家和其他创意人才的作品和信息。
企业博客：许多企业都拥有自己的博客来发布公司新闻、产品更新、行业见解等内容。Ghost提供了一个灵活且易于定制的平台，可以满足企业博客的需求。
下载Ghost镜像
bash
[root@docker ~]# docker pull ghost
Using default tag: latest
latest: Pulling from library/ghost
302e3ee49805: Already exists
f4523b1e3485: Pull complete
643a6ed41aef: Pull complete
23663f1b1336: Pull complete
2fad2dcef2d4: Pull complete
3f316e596507: Pull complete
bf2a403ec6b6: Pull complete
9b79a6ed50e6: Pull complete
4f4fb700ef54: Pull complete
dce26c7b2132: Pull complete
Digest: sha256:a8dbbc0bfe9b57148b97ad4fa58064dd58b3bfcd019fe90fa60e5d5cd9b77750
Status: Downloaded newer image for ghost:latest
docker.io/library/ghost:latest部署Ghost开源内容管理系统
创建数据目录
bash
[root@docker ~]# mkdir -p /data/ghost创建Ghost容器
bash
[root@docker ~]# docker run -d \
--restart always \
--name ghost \
-p 2368:2368 \
-v /data/ghost:/var/lib/ghost/content \
-e NODE_ENV=development \
-e curl=http://192.168.3.166:2368 \
ghost
50462e8dc684336b1124fcf5372cb78019362f78dbffde2838229011084571ca目录授权
bash
[root@docker ~]# chmod -R 777 /data/ghost/重启ghost容器
bash
[root@docker ~]# docker restart ghost
ghost检查Ghost容器状态
检查Ghost容器状态，确保容器正常启动
bash[root@docker ~]# docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 50462e8dc684 ghost "docker-entrypoint.s..." About a minute ago Up 15 seconds 0.0.0.0:2368->2368/tcp, :::2368->2368/tcp ghost
检查Ghost容器运行日志
查Ghost容器运行日志，检查有无报错，确保Ghost服务正常启动。
bash
[root@docker ~]# docker logs ghost
[2024-10-08 15:23:03] INFO Ghost is running in development...
[2024-10-08 15:23:03] INFO Listening on: :::2368
[2024-10-08 15:23:03] INFO Url configured as: http://192.168.3.166:2368/
[2024-10-08 15:23:03] INFO Ctrl+C to shut down
[2024-10-08 15:23:03] INFO Ghost server started in 0.4s
[2024-10-08 15:23:03] WARN Database state requires initialisation.
[2024-10-08 15:23:03] INFO Creating table: newsletters
[2024-10-08 15:23:03] INFO Creating table: posts
[2024-10-08 15:23:03] INFO Creating table: posts_meta
[2024-10-08 15:23:03] INFO Creating table: users
[2024-10-08 15:23:03] INFO Creating table: posts_authors
[2024-10-08 15:23:03] INFO Creating table: roles
[2024-10-08 15:23:03] INFO Creating table: roles_users
[2024-10-08 15:23:03] INFO Creating table: permissions
[2024-10-08 15:23:03] INFO Creating table: permissions_users
[2024-10-08 15:23:03] INFO Creating table: permissions_roles
[2024-10-08 15:23:03] INFO Creating table: settings
[2024-10-08 15:23:03] INFO Creating table: tags
[2024-10-08 15:23:03] INFO Creating table: posts_tags
[2024-10-08 15:23:03] INFO Creating table: invites
[2024-10-08 15:23:03] INFO Creating table: brute
[2024-10-08 15:23:03] INFO Creating table: sessions
[2024-10-08 15:23:03] INFO Creating table: integrations
[2024-10-08 15:23:03] INFO Creating table: webhooks
[2024-10-08 15:23:03] INFO Creating table: api_keys
[2024-10-08 15:23:03] INFO Creating table: mobiledoc_revisions
[2024-10-08 15:23:03] INFO Creating table: post_revisions
[2024-10-08 15:23:03] INFO Creating table: members
[2024-10-08 15:23:03] INFO Creating table: products
[2024-10-08 15:23:03] INFO Creating table: offers
[2024-10-08 15:23:03] INFO Creating table: benefits
[2024-10-08 15:23:03] INFO Creating table: products_benefits
[2024-10-08 15:23:03] INFO Creating table: members_products
[2024-10-08 15:23:03] INFO Creating table: posts_products
[2024-10-08 15:23:03] INFO Creating table: members_created_events
[2024-10-08 15:23:03] INFO Creating table: members_cancel_events
[2024-10-08 15:23:03] INFO Creating table: members_payment_events
[2024-10-08 15:23:03] INFO Creating table: members_login_events
[2024-10-08 15:23:03] INFO Creating table: members_email_change_events
[2024-10-08 15:23:03] INFO Creating table: members_status_events
[2024-10-08 15:23:03] INFO Creating table: members_product_events
[2024-10-08 15:23:03] INFO Creating table: members_paid_subscription_events
[2024-10-08 15:23:03] INFO Creating table: labels
[2024-10-08 15:23:03] INFO Creating table: members_labels
[2024-10-08 15:23:03] INFO Creating table: members_stripe_customers
[2024-10-08 15:23:03] INFO Creating table: subscriptions
[2024-10-08 15:23:03] INFO Creating table: members_stripe_customers_subscriptions
[2024-10-08 15:23:03] INFO Creating table: members_subscription_created_events
[2024-10-08 15:23:03] INFO Creating table: offer_redemptions
[2024-10-08 15:23:03] INFO Creating table: members_subscribe_events
[2024-10-08 15:23:03] INFO Creating table: donation_payment_events
[2024-10-08 15:23:03] INFO Creating table: stripe_products
[2024-10-08 15:23:04] INFO Creating table: stripe_prices
[2024-10-08 15:23:04] INFO Creating table: actions
[2024-10-08 15:23:04] INFO Creating table: emails
[2024-10-08 15:23:04] INFO Creating table: email_batches
[2024-10-08 15:23:04] INFO Creating table: email_recipients
[2024-10-08 15:23:04] INFO Creating table: email_recipient_failures
[2024-10-08 15:23:04] INFO Creating table: tokens
[2024-10-08 15:23:04] INFO Creating table: snippets
[2024-10-08 15:23:04] INFO Creating table: custom_theme_settings
[2024-10-08 15:23:04] INFO Creating table: members_newsletters
[2024-10-08 15:23:04] INFO Creating table: comments
[2024-10-08 15:23:04] INFO Creating table: comment_likes
[2024-10-08 15:23:04] INFO Creating table: comment_reports
[2024-10-08 15:23:04] INFO Creating table: jobs
[2024-10-08 15:23:04] INFO Creating table: redirects
[2024-10-08 15:23:04] INFO Creating table: members_click_events
[2024-10-08 15:23:04] INFO Creating table: members_feedback
[2024-10-08 15:23:04] INFO Creating table: suppressions
[2024-10-08 15:23:04] INFO Creating table: email_spam_complaint_events
[2024-10-08 15:23:04] INFO Creating table: mentions
[2024-10-08 15:23:04] INFO Creating table: milestones
[2024-10-08 15:23:04] INFO Creating table: temp_mail_events
[2024-10-08 15:23:04] INFO Creating table: collections
[2024-10-08 15:23:04] INFO Creating table: collections_posts
[2024-10-08 15:23:04] INFO Creating table: recommendations
[2024-10-08 15:23:04] INFO Creating table: recommendation_click_events
[2024-10-08 15:23:04] INFO Creating table: recommendation_subscribe_events
[2024-10-08 15:23:13] INFO Model: Collection
[2024-10-08 15:23:13] INFO Model: Product
[2024-10-08 15:23:13] INFO Model: Newsletter
[2024-10-08 15:23:13] INFO Model: Tag
[2024-10-08 15:23:13] INFO Model: Permission
[2024-10-08 15:23:13] INFO Model: Post
[2024-10-08 15:23:13] INFO Model: Integration
[2024-10-08 15:23:13] INFO Relation: Role to Permission
[2024-10-08 15:23:13] INFO Relation: Post to Tag
[2024-10-08 15:23:13] INFO Database is in a ready state.
[2024-10-08 15:23:13] INFO Ghost database ready in 10.765s
[2024-10-08 15:23:15] INFO Adding offloaded job to the queue
[2024-10-08 15:23:15] INFO Scheduling job mentions-email-report at 12 48 * * * *. Next run on: Tue Oct 08 2024 15:48:12 GMT+0000 (Coordinated Universal Time)
[2024-10-08 15:23:15] INFO Adding one-off job to queue with current length = 0 called 'members-migrations'
[2024-10-08 15:23:15] INFO Stripe not configured - skipping migrations
[2024-10-08 15:23:15] INFO Ghost URL Service Ready in 12.297s
[2024-10-08 15:23:15] INFO Adding offloaded job to the queue
[2024-10-08 15:23:15] INFO Scheduling job clean-expired-comped at 0 15 2 * * *. Next run on: Wed Oct 09 2024 02:15:00 GMT+0000 (Coordinated Universal Time)
[2024-10-08 15:23:15] INFO Adding offloaded job to the queue
[2024-10-08 15:23:15] INFO Scheduling job clean-tokens at 20 17 2 * * *. Next run on: Wed Oct 09 2024 02:17:20 GMT+0000 (Coordinated Universal Time)
[2024-10-08 15:23:15] INFO Ghost booted in 12.633s
[2024-10-08 15:23:15] INFO Adding offloaded job to the queue
[2024-10-08 15:23:15] INFO Scheduling job update-check at 4 44 20 * * *. Next run on: Tue Oct 08 2024 20:44:04 GMT+0000 (Coordinated Universal Time)
[2024-10-08 15:23:15] INFO Running milestone emails job on Tue Oct 08 2024 15:23:20 GMT+0000 (Coordinated Universal Time)
[2024-10-08 15:23:55] WARN Ghost is shutting down
[2024-10-08 15:23:55] WARN Ghost has shut down
[2024-10-08 15:23:55] WARN Ghost was running for a minute
[2024-10-08 15:23:56] INFO Ghost is running in development...
[2024-10-08 15:23:56] INFO Listening on: :::2368
[2024-10-08 15:23:56] INFO Url configured as: http://192.168.3.166:2368/
[2024-10-08 15:23:56] INFO Ctrl+C to shut down
[2024-10-08 15:23:56] INFO Ghost server started in 0.376s
[2024-10-08 15:23:56] INFO Database is in a ready state.
[2024-10-08 15:23:56] INFO Ghost database ready in 0.468s
[2024-10-08 15:23:57] INFO Adding offloaded job to the queue
[2024-10-08 15:23:57] INFO Scheduling job mentions-email-report at 34 34 * * * *. Next run on: Tue Oct 08 2024 15:34:34 GMT+0000 (Coordinated Universal Time)
[2024-10-08 15:23:57] INFO Adding offloaded job to the queue
[2024-10-08 15:23:57] INFO Scheduling job clean-expired-comped at 15 1 0 * * *. Next run on: Wed Oct 09 2024 00:01:15 GMT+0000 (Coordinated Universal Time)
[2024-10-08 15:23:57] INFO Adding offloaded job to the queue
[2024-10-08 15:23:57] INFO Scheduling job clean-tokens at 38 6 15 * * *. Next run on: Wed Oct 09 2024 15:06:38 GMT+0000 (Coordinated Universal Time)
[2024-10-08 15:23:57] INFO Ghost booted in 1.969s
[2024-10-08 15:23:57] INFO Adding offloaded job to the queue
[2024-10-08 15:23:57] INFO Scheduling job update-check at 51 38 18 * * *. Next run on: Tue Oct 08 2024 18:38:51 GMT+0000 (Coordinated Universal Time)
[2024-10-08 15:23:57] INFO Running milestone emails job on Tue Oct 08 2024 15:24:02 GMT+0000 (Coordinated Universal Time)
[2024-10-08 15:23:57] INFO Ghost URL Service Ready in 2.202s访问Ghost首页
访问地址： http://192.168.108.30:2368，将IP替换为自己服务器IP地址，如果无法访问到该页面，注意自己服务器的防火墙是否关闭或者放行相关端口，使用云服务器则还需要设置安全组规则。
进入账号注册页面
