Dockers核心技术精讲

一、Dockers核心技术精讲

虚拟化起源史：

第一阶段：Linux服务器

服务器就是在机房里放的有完整操作系统的机器，Linux 是一个操作系统，linux 服务器就和 Windows 的服务器是一样的，都是在网络环境或分布式处理环境中，为用户提供服务，可分为访问服务器、文件服务器、数据库服务器、通信服务器和应用服务器等。常见的 Linux 服务器的系统主要包括 debian 系（debian、ubuntu）、redhat 系(redhat、centos)，suse、rockylinux、麒麟、欧拉等，同一类发行版用法相似。

优点：

1）提供稳定性，因为基于 Linux 的服务器不容易崩溃。在遇到碰撞的情况下，整个系统都不受影响。

2）Linux 非常适合阻止或防止可疑恶意软件进入并影响整个系统的性能。

3）拥有耐用性，因为它可以长时间运行，一年不关机也不会影响性能。

4）大多数 Linux 发行版是免费下载的，可以安装在自己个人电脑上

第二阶段：虚拟机

虚拟机（VM）指通过软件模拟的具有完整硬件系统功能的、运行在一个完全隔离环境中的完整计算机系统。简单讲是可以实现在一台物理计算机上模拟多台计算机运行任务。常见虚拟机：Vmware Workstation、VirtualBox、KVM、Hyper-V、Xen 等

优点：

1、一台主机，通过安装不同系统环境的虚拟机、与运行单独的实体服务器相比是经济的。

2、虚拟机与主机操作系统隔离，虚拟机上的操作不影响主机

第三阶段：容器化

容器是一种沙盒技术，主要目的是为了将应用运行在其中，与外界隔离；及方便这个沙盒可以被转移到其它宿主机器。通俗点的理解就是一个装应用软件的箱子，箱子里面有软件运行所需的依赖库和配置。开发人员可以把这个箱子搬到任何机器上，且不影响里面软件的运行。

优点：

1.环境的强一致性。docker 镜像提供了除内核外完整的运行时环境，保证其他使用人员，能完整复现应用运行时环境。不会出现“这应用在 xxx 环境没问题”这种情况。

2.迁移方便，持续交付和部署。一次打包，到处运行。

所以，欢迎进入容器化时代，目前主流容器，分别是：Docker，k8s(kubernetes)

注：

k8s1.24版本和1.24之后的版本使用：containerd

k8s1.24之前：docker容器运行时

二、Docker的概述

1、背景

Docker 的思想来自于集装箱，集装箱解决了什么问题？在一艘大船上，可以把货物规整的摆放起来。并且各种各样的货物被装在集装箱里，集装箱和集装箱之间不会互相影响。那么我就不需要专门运送蔬菜的船和专门运送货物的船了。只要这些货物在集装箱里封装的好好的，那我就可以用一艘大船把他们都运走。 docker 就是类似的理念。云计算就好比大货轮。docker 就是集装箱。

2、docker 的优点

1）快

运行时的性能快，管理操作(启动，停止，开始，重启等等) 都是以秒或毫秒为单位的。

2）敏捷

像虚拟机一样敏捷，而且会更便宜，在 bare metal(裸机)上布署像点个按钮一样简单。

3）灵活

将应用和系统“容器化”，不添加额外的操作系统

4）轻量

在一台服务器上可以布署 100~1000 个 Containers 容器。

5）便宜

开源的，免费的，低成本的。

docker-ce：社区版

docker-ee: 商业版

3、docker 缺点

所有容器共用 linux kernel 资源，资源能否实现最大限度利用，所以在安全上也会存在漏洞。

4、docker安装

4.1 安装基础环境

# 配置主机名
hostnamectl set-hostname jiang && bash
 
# 关闭防火墙
systemctl stop firewalld && systemctl disable firewalld

# 关闭 iptables 防火墙
yum install iptables-services -y #安装 iptables
service iptables stop && systemctl disable iptables
# 清空防火墙规则
iptables -F

#关闭 selinux
setenforce 0
sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config
# 注意：修改 selinux 配置文件之后，重启机器，selinux 才能永久生效

getenforce
# 显示 Disabled 表示 selinux 关闭成功

#配置时间同步 
yum install -y ntp ntpdate 
ntpdate cn.pool.ntp.org 
#编写计划任务 
crontab -e 
* */1 * * * /usr/sbin/ntpdate cn.pool.ntp.org 

# 重启 crond 服务使配置生效： 
systemctl restart crond

# 安装基础软件包
yum install -y wget net-tools nfs-utils lrzsz gcc gcc-c++ make cmake libxml2-devel openssl-devel curl curl-devel unzip sudo ntp libaio-devel wget vim ncurses-devel autoconf automake zlib-devel python-devel epel-release openssh-server socat ipvsadm conntrack

4.2 安装Docker-ce

# 安装 docker 依赖包 
yum install -y yum-utils device-mapper-persistent-data lvm2 

# 配置 docker-ce 国内 yum 源（阿里云） 
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
 
# 查看docker版本
yum list docker-ce --showduplicates | sort -r
# 安装指定版本
yum install -y docker-ce-18.09.9 docker-ce-cli-18.09.9 containerd.io

# 安装 docker-ce 最新版
yum install docker-ce -y 
 
 
# 启动 docker 服务 
systemctl start docker && systemctl enable docker 
systemctl status docker

# 查看 Docker 版本信息
docker version

4.3 开启包转发功能和修改内核参数

内核参数修改：br_netfilter 模块用于将桥接流量转发至 iptables 链，br_netfilter 内核参数需要开启转发。

不开启ipv4转发的话，在容器中暴露端口，访问不到地址。、

modprobe br_netfilter 
cat > /etc/sysctl.d/docker.conf << EOF 
	net.bridge.bridge-nf-call-ip6tables = 1 
	net.bridge.bridge-nf-call-iptables = 1 
	net.ipv4.ip_forward = 1 
EOF 
 
# 使参数生效 
sysctl -p /etc/sysctl.d/docker.conf 
 
# 重启后模块失效，下面是开机自动加载模块的脚本 
# 在/etc/新建 rc.sysinit 文件 

cat /etc/rc.sysinit 
#!/bin/bash 
for file in /etc/sysconfig/modules/*.modules ; do 
[ -x $file ] && $file 
done 
 
# 在/etc/sysconfig/modules/目录下新建文件如下 
cat /etc/sysconfig/modules/br_netfilter.modules 
modprobe br_netfilter  # 输出
 
# 增加权限 
chmod 755 /etc/sysconfig/modules/br_netfilter.modules 
 
# 重启机器模块也会自动加载 
lsmod |grep br_netfilter 
# 输出
br_netfilter 22209 0 
bridge 136173 1 br_netfilter

# 重启docker
 systemctl restart docker

4.4 开启云加速器

登录阿里云镜像仓库：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://b07cesj8.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

# 其他镜像加速器
# docker中国区官方镜像加速：
https://registry.docker-cn.com

# 网易镜像加速：
http://hub-mirror.c.163.com

# 中国科技大学镜像加速：
https://docker.mirrors.ustc.edu.cn

# 腾讯云镜像加速：
https://mirror.ccs.tencentyun.com

4.5 实战nginx

# 创建容器
docker run --name centos -p 80 -itd centos
docker ps | grep centos

# 进入容器
docker exec -it centos /bin/bash
 
# 由于centos不在维护，需要修改yum源
rm -rf /etc/yum.repos.d/* 
curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-
8.5.2111.repo 

# 安装插件
yum install wget -y 
yum install nginx -y

5、docker问题：

Docker 安装后出现：WARNING: bridge-nf-call-iptables is disabled 的解决办法：

# 参考4.3章节
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1

将 Linux 系统作为路由或者 VPN 服务就必须要开启 IP 转发功能。当 linux 主机有多个网卡时一个网卡收到的信息是否能够传递给其他的网卡，如果设置成 1 的话可以进行数据包转发，可以实现 VxLAN 等功能。不开启会导致 docker 部署应用无法访问。

三、containerd 容器概述

官方文档:

https://containerd.io

在 2016 年 12 月 14 日，Docker 公司宣布将 containerd 从 Docker 中分离，由开源社区独立发展和运营。Containerd 完全可以单独运行并管理容器，而 Containerd 的主要职责是镜像管理和容器执行。同时，Containerd 提供了 containerd-shim 接口封装层，向下继续对接 runC 项目，使得容器引擎 Docker Daemon 可以独立升级。

Containerd 可以在宿主机中管理完整的容器生命周期：容器镜像的传输和存储、容器的执行和管理、存储和网络等。总结一下，它主要负责干以下事情：

• 管理容器的生命周期(从创建容器到销毁容器)

• 拉取/推送容器镜像

• 存储管理(管理镜像及容器数据的存储)

• 调用 runC 运行容器(与 runC 等容器运行时交互)

• 管理容器网络接口及网络

ctr：containerd 的命令行客户端。

1、Containerd 和 Docker 之间的关系

Docker 包含 Containerd，Containerd 专注于运行时的容器管理，而 Docker 除了容器管理之外，还可以完成镜像构建之类的功能。

Containerd 提供的 API 偏底层，不是给普通用户直接用的，容器编排的开发者才需要Containerd。

2、Containerd 在容器生态中扮演的角色

Containerd 并不是直接面向最终用户的，而是主要用于集成到更上层的系统里，比如 Kubernetes等容器编排系统。

Containerd 以 daemon 的形式运行在系统上，通过 unix domain socket 暴露底层的 grpc API，上层系统可以通过这些 API 管理机器上的容器。

2-1 K8S 为什么要放弃使用 Docker 作为容器运行时，而使用 containerd 呢？

说白了，就是containerd更接近底层，跟docker比，占用资源更少，而且docker底层也是用的containerd

Docker，Kubernetes 等工具来运行一个容器时会调用容器运行时（CRI），比如 containerd，CRI-O，通过容器运行时来完成容器的创建、运行、销毁等实际工作，Docker 使用的是 containerd 作为其运行时；Kubernetes 支持 docker（在 k8s1.24 版本之前用，1.24 开始废弃了）、containerd，

CRI-O 等多种容器运行时，这些容器运行时都遵循了 OCI 规范，并通过 runc 来实现与操作系统内核交互来完成容器的创建和运行

CRI

CRI 是一个插件接口，它使 kubelet 能够使用各种容器运行时，你需要在集群中的每个节点上都有一个

可以正常工作的容器运行时，这样 kubelet 能启动 Pod 及其容器。容器运行时接口（CRI）是

kubelet 和容器运行时之间通信的主要协议。

OCI：

OCI， Open Container Initiative ，是一个轻量级，开放的治理结构（项目），在 Linux 基金会的支

持下成立，致力于围绕容器格式和运行时创建开放的行业标准。 OCI 项目由 Docker，CoreOS（后来

被 Red Hat 收购了，相应的席位被 Red Hat 继承）和容器行业中的其他领导者在 2015 年 6 月的时

候启动。

如果你使用 Docker 作为 K8S 容器运行时的话，kubelet 需要先要通过 dockershim 去调用 Docker，

再通过 Docker 去调用 containerd。

如果你使用 containerd 作为 K8S 容器运行时的话， kubelet 可以直接调用 containerd。

使用 containerd 不仅性能提高了（调用链变短了），而且资源占用也会变小（Docker 不是一个纯粹的

容器运行时，具有大量其他功能）。

调用链

Docker 作为 k8s 容器运行时，调用关系如下：

kubelet –> docker shim （在 kubelet 进程中） –> dockerd –> containerd

Containerd 作为 k8s 容器运行时，调用关系如下：

kubelet –> cri plugin（在 containerd 进程中） –> containerd

3、containerd 安装和配置

注：安装 docker 会自动把 containerd 安装出来，也可以通过如下命令直接安装 containerd。

# 需要配置 docker-ce.repo 这个 yum 源：
yum install yum-utils -y
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum install containerd -y
systemctl enable containerd
systemctl start containerd

# 初始化 Containerd 配置：
containerd config default > /etc/containerd/config.toml
systemctl enable containerd
systemctl start containerd

# 替换 containerd 默认的 sand_box 镜像，编辑/etc/containerd/config.toml 文件：
sandbox_image = "k8s.gcr.io/pause:3.2" 替换成 registry.cnhangzhou.aliyuncs.com/google_containers/pause-amd64:3.2

# 应用配置并重新运行 containerd 服务
systemctl daemon-reload
systemctl restart containerd
systemctl status containerd

4、containerd使用

containerd和docker不同，他通过名称空间进行隔离资源，docker和containerd的镜像可以通用，因为docker底层用的containerd

# 查看 containerd 命名空间
ctr namespace ls

# ctr 有命名空间 namespace 来指定类似于工作空间的隔离区域。使用方法 ctr -n default images ls 
# 来查看 default 命名空间的镜像，不加 -n 参数，默认也是使用 default 的命名空间。

#查看默认名称空间镜像有哪些
ctr image ls

#查看 k8s 命名空间下的镜像
ctr -n=k8s.io images ls

# 拉取 busybox 镜像
ctr image pull docker.io/library/busybox:latest
# 注：必须全路径，从 dockerhub 上下载默认 busybox 镜像。

# 删除镜像
ctr images rm <镜像名称>

# 压缩镜像
ctr images pull docker.io/library/mysql:latest
ctr images export mysql.tar.gz docker.io/library/mysql:latest

# 导入镜像
ctr images import mysql.tar.gz

5、docker 的镜像和 containerd 镜像通用吗？

通用的，docker save -o 生成的镜像文件，可以基于 ctr images import 导出来

四、Dockerfile语法详解

Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明。

	基于 Dockerfile 构建镜像可以使用 docker build 命令。docker build 命令中使用-f 可以指定具体的

dockerfile 文件

示例：

FROM centos 
MAINTAINER jiang
RUN rm -rf /etc/yum.repos.d/* 
COPY Centos-vault-8.5.2111.repo /etc/yum.repos.d/ 
RUN yum install wget -y 
ADD jdk-8u45-linux-x64.rpm /usr/local/ 
ADD apache-tomcat-8.0.26.tar.gz /usr/local/ 
RUN cd /usr/local && rpm -ivh jdk-8u45-linux-x64.rpm 
RUN mv /usr/local/apache-tomcat-8.0.26 /usr/local/tomcat8 
ENTRYPOINT /usr/local/tomcat8/bin/startup.sh && tail -F 
/usr/local/tomcat8/logs/catalina.out 
EXPOSE 8080

# docker build -t mycentos .

dockerfile 构建过程：

从基础镜像运行一个容器
执行一条指令，对容器做出修改
执行类似 docker commit 的操作，提交一个新的镜像层
再基于刚提交的镜像运行一个新的容器
执行 dockerfile 中的下一条指令，直至所有指令执行完毕

参数简单描述：
（1）FROM # 拉取镜像
（2）MAINTAINER # 指定镜像的作者信息 
（3）RUN # 指定在当前镜像构建过程中要运行的命令 ，格式：RUN echo hello
（4）EXPOSE # 暴露端口， 格式：EXPOSE <端口 1> [<端口 2>...] 
（5）CMD # 用于启动镜像，最后执行，格式：  CMD[“executable”，“param1”，“param2”]
（6）ENTERYPOINT # 和CMD类似，最后一个执行，格式：ENTERYPOINT [“executable”,“param1”,“param2”]
（7）COPY # 复制文件到容器，COPY [--chown=<user>:<group>] <源路径 1>... <目标路径> 
（8）ADD # 将文件拷贝到容器，进行解压，单纯复制用copy命令。格式：ADD <src> <dest>
（9）VOLUME # 指定数据卷，格式：VOLUME ["<路径 1>", "<路径 2>"...] || VOLUME <路径>  
（10）WORKDIR # 指定进入容器后的位置，格式：WORKDIR <工作目录路径> 
 (11) ENV # 设置环境变量，格式： ENV <key> <value> ||ENV <key>=<value>... 
（12）USER # 指定进入容器的用户，必须存在，格式：USER <用户名>[:<用户组>] 
（13）ONBUILD # 如果其他容器用该容器做基础镜像执行。
（14）LABEL # 容器打标签，LABEL authors="jiang"  images="jiang"（多个空格隔开）
（15）HEALTHCHECK # 容器健康检查，判断容器是否启动，屏蔽检查 HEALTHCHECK NONE，最后一个执行
（16）ARG # 环境变量，仅对dockerfile文件生效

参数详细说明：

（1）FROM 
基础镜像，必须是可以下载下来的，定制的镜像都是基于 FROM 的镜像，这里的 centos 就是定制需要的
基础镜像。后续的操作都是基于 centos 镜像。 
（2）MAINTAINER 
指定镜像的作者信息 
 
（3）RUN：指定在当前镜像构建过程中要运行的命令 
    包含两种模式 
    1、Shell 
    RUN <command> (shell 模式，这个是最常用的，需要记住) 
    RUN echo hello 

    2、exec 模式
    RUN [“executable”，“param1”，“param2”](exec 模式) 
    RUN [“/bin/bash”,”-c”,”echo hello”]
    等价于/bin/bash -c echo hello
 （4）EXPOSE 指令 
    仅仅只是声明端口。 
    作用： 
    1、帮助镜像使用者理解这个镜像服务的守护端口，以方便配置映射。 
    2、在运行时使用随机端口映射时，也就是 docker run -P 时，会自动随机映射 EXPOSE 的端口。 

    3、可以是一个或者多个端口，也可以指定多个 EXPOSE 

    格式：EXPOSE <端口 1> [<端口 2>...] 
 
（5）CMD 
    类似于 RUN 指令，用于运行程序，但二者运行的时间点不同: 
    1、CMD 在 docker run 时运行。 
    2、RUN 是在 docker build 构建镜像时运行的 

    作用：为启动的容器指定默认要运行的程序，程序运行结束，容器也就结束。CMD 指令指定的程序可被
    docker run 命令行参数中指定要运行的程序所覆盖。

    CMD[“executable”，“param1”，“param2”]（exec 模式） 
    CMD command （shell 模式） 
    CMD [“param1”,”param2”](作为 ENTRYPOINT 指令的默认参数) 
（6）ENTERYPOINT 
    类似于 CMD 指令，但其不会被 docker run 的命令行参数指定的指令所覆盖，而且这些命令行参数会被
    当作参数送给 ENTRYPOINT 指令指定的程序。 
    但是, 如果运行 docker run 时使用了 --entrypoint 选项，将覆盖 entrypoint 指令指定的程序。 
    优点：在执行 docker run 的时候可以指定 ENTRYPOINT 运行所需的参数。 
    注意：如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。 
    格式： 

    ENTERYPOINT [“executable”,“param1”,“param2”](exec 模式) 
    ENTERYPOINT command （shell 模式） 

    可以搭配 CMD 命令使用：一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参，以下
    示例会提到。 
    示例： 
    假设已通过 Dockerfile 构建了 nginx:test 镜像： 
    FROM nginx 
    ENTRYPOINT ["nginx", "-c"] # 定参 
    CMD ["/etc/nginx/nginx.conf"] # 变参 

    1、不传参运行 
    $ docker run nginx:test 

    容器内会默认运行以下命令，启动主进程。 
    nginx -c /etc/nginx/nginx.conf 

    2、传参运行 
    $ docker run nginx:test -c /etc/nginx/new.conf 
    容器内会默认运行以下命令，启动主进程(/etc/nginx/new.conf:假设容器内已有此文件) 
    nginx -c /etc/nginx/new.conf 
 
（7）COPY 
    COPY<src>..<dest> 
    COPY[“<src>”...“<dest>”] 

    复制指令，从上下文目录中复制文件或者目录到容器里指定路径。 

    格式： 
    COPY [--chown=<user>:<group>] <源路径 1>... <目标路径> 
    COPY [--chown=<user>:<group>] ["<源路径 1>",... "<目标路径>"]
    [--chown=<user>:<group>]：可选参数，用户改变复制到容器内文件的拥有者和属组。
    规则。例如： 
        COPY hom* /mydir/ 
        COPY hom?.txt /mydir/ 

        <目标路径>：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建。
 （8）ADD 
    ADD <src>...<dest> 
    ADD [“<src>”...“<dest>”] 

    ADD 指令和 COPY 的使用格式一致（同样需求下，官方推荐使用 COPY）。功能也类似，不同之处如下： 

    ADD 的优点：在执行 <源文件> 为 tar 压缩文件的话，压缩格式为 gzip, bzip2 以及 xz 的情况下，
    会自动复制并解压到 <目标路径>。 
    ADD 的缺点：在不解压的前提下，无法复制 tar 压缩文件。会令镜像构建缓存失效，从而可能会令镜像
    构建变得比较缓慢。具体是否使用，可以根据是否需要自动解压来决定。 


    ADD vs COPY 
    ADD 包含类似 tar 的解压功能 
    如果单纯复制文件，dockerfile 推荐使用 COPY 


    例;替换/usr/share/nginx 下的 index.html 
    cd /root/dockerfile/test1 
    cat dockerfile 
    FROM centos 
    MAINTAINER xianchao 
    RUN yum install wget -y 
    RUN yum install nginx -y 
    COPY index.html /usr/share/nginx/html/ 
    EXPOSE 80 
    ENTRYPOINT ["/usr/sbin/nginx","-g","daemon off;"] 

    vim index.html 
    <html> 
    <head>
   （9）VOLUME 
定义匿名数据卷。在启动容器时忘记挂载数据卷，会自动挂载到匿名卷。 
作用： 
1、避免重要的数据，因容器重启而丢失，这是非常致命的。 
2、避免容器不断变大。 
格式： 
VOLUME ["<路径 1>", "<路径 2>"...] 
VOLUME <路径> 
在启动容器 docker run 的时候，我们可以通过 -v 参数修改挂载点。 
 
VOLUME [“/data”] 
 
（10）WORKDIR 
    指定工作目录。用 WORKDIR 指定的工作目录，会在构建镜像的每一层中都存在。（WORKDIR 指定的工作
    目录，必须是提前创建好的）。 
    docker build 构建镜像过程中的，每一个 RUN 命令都是新建的一层。只有通过 WORKDIR 创建的目录才

    会一直存在。 
    格式： 
    WORKDIR <工作目录路径> 

    WORKDIR /path/to/workdir 
    （填写绝对路径） 
 
(11 )ENV 
    设置环境变量 
    ENV <key> <value> 
    ENV <key>=<value>... 

    以下示例设置 NODE_VERSION =6.6.6， 在后续的指令中可以通过 $NODE_VERSION 引用： 
    ENV NODE_VERSION 6.6.6 

    RUN curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" 
    \ 
     && curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/SHASUMS256.txt.asc" 
 
（12）USER 
    用于指定执行后续命令的用户和用户组，这边只是切换后续命令执行的用户（用户和用户组必须提前已
    经存在）。 
    格式： 
    USER <用户名>[:<用户组>] 

    USER daemon 
    USER nginx 
    USER user 
    USER uid 
    USER user:group 
    USER uid:gid 
    USER user:gid 
    USER uid:group 
 
（13）ONBUILD 
    用于延迟构建命令的执行。简单的说，就是 Dockerfile 里用 ONBUILD 指定的命令，在本次构建镜
    像的过程中不会执行（假设镜像为 test-build）。当有新的 Dockerfile 使用了之前构建的镜像 FROM 
    test-build ，这时执行新镜像的 Dockerfile 构建时候，会执行 test-build 的 Dockerfile 里的 
    ONBUILD 指定的命令。 
    格式： 
    ONBUILD <其它指令> 

    为镜像添加触发器当一个镜像被其他镜像作为基础镜像时需要写上 OBNBUILD 会在构建时插入触发器指令
（14）LABEL 
    LABEL 指令用来给镜像添加一些元数据（metadata），以键值对的形式，语法格式如下：
    LABEL <key>=<value> <key>=<value> <key>=<value> ...
    比如我们可以添加镜像的作者：
    LABEL org.opencontainers.image.authors="xianchao"
 
（15）HEALTHCHECK 
    用于指定某个程序或者指令来监控 docker 容器服务的运行状态。
    格式：
    HEALTHCHECK [选项] CMD <命令>：设置检查容器健康状况的命令
    HEALTHCHECK NONE：如果基础镜像有健康检查指令，使用这行可以屏蔽掉其健康检查指令
    HEALTHCHECK [选项] CMD <命令> : 这边 CMD 后面跟随的命令使用，可以参考 CMD 的用法。
    
    选项
    --interval=<间隔> ：两次健康检查的间隔，默认为 30 秒；
    --timeout=<时长> ：健康检查命令运行超时时间，如果超过这个时间，本次健康检查就被视为失败，默认 30 秒；
    --retries=<次数> ：当连续失败指定次数后，则将容器状态视为 unhealthy ，默认 3 次
    
    举例：
    FROM nginx
	RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
	HEALTHCHECK --interval=5s --timeout=3s \
	CMD curl -fs http://localhost/ || exit 1
	# 如果返回 1 则退出

	# 执行 docker build
	$ docker build -f HEALTHCHEK.dockerifle -t myweb .
（16）ARG 
    构建参数，与 ENV 作用一至。不过作用域不一样。ARG 设置的环境变量仅对 Dockerfile 内有效，也就
    是说只有 docker build 的过程中有效，构建好的镜像内不存在此环境变量。
    构建命令 docker build 中可以用 --build-arg <参数名>=<值> 来覆盖。
    格式：
    ARG <参数名>[=<默认值>]

五、将编译后的文件进行构建

1、将go代码进行构建镜像

把 Go 代码基于 dockerfile 做成镜像 
1、linux 机器安装 go（我用的是 centos7.9 操作系统） 
[root@master1 ~]# yum install go -y 
2、创建源码文件 
生产环境代码是开发人员写的，运维不用写 
[root@master1 ~]# mkdir test 
[root@master1 ~]# cd test/ 
[root@master1 test]# cat main.go 
package main 
 
import ( 
 "net/http" 
 
 "github.com/gin-gonic/gin" 
) 
 
func statusOKHandler(c *gin.Context) { 
 c.JSON(http.StatusOK, gin.H{"status": "success~welcome to study"}) 
} 
 
func versionHandler(c *gin.Context) { 
 c.JSON(http.StatusOK, gin.H{"version": "v1.1 版本"}) 
} 
 
func main() { 
 router := gin.New() 
 router.Use(gin.Recovery()) 
 router.GET("/", statusOKHandler) 
 router.GET("/version", versionHandler) 
 router.Run(":8080") 
} 
 
3、Go mod 初始化项目 
[root@master1 test]# go mod init test 
#设置代理 
[root@master1 test]# go env -w GOPROXY=https://goproxy.cn,direct 
[root@master1 test]# go mod tidy 
#构建源码 
[root@master1 test]# CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o k8s-demo 
main.go

构建镜像

 
4、编写 dockerfile 文件 
[root@master1 test]# cat Dockerfile 
FROM alpine 
WORKDIR /data/app 
ADD k8s-demo /data/app/ 
CMD ["/bin/sh","-c","./k8s-demo"] 
 
5、构建镜像 
[root@master1 test]# docker build -t xianchao/k8sdemo:v1 . 
 
6、运行镜像 
[root@master1 test]# docker run -d --name go -p 30180:8080 xianchao/k8sdemo:v1 
 
7、访问 go 容器 
可以在根物理机同网段的其他机器或者浏览器访问 master1 机器的 ip:30180，就可以把请求代
理到 go 容器了

2、将java代码构建成镜像

FROM java:8

#COPY target/dockerk8sdome-0.0.1-SNAPSHOT.jar dockerk8sdome.jar
COPY dockerk8sdome-0.0.1-SNAPSHOT.jar dockerk8sdome.jar

# 开放端口
EXPOSE 8080

ENTRYPOINT ["java","-jar","dockerk8sdome.jar"]

六、Docker 数据卷管理

什么是数据卷？

简单来说：就是对docker的容器与主机同步数据，实现容器的数据持久化操作。

数据卷是经过特殊设计的目录，可以绕过联合文件系统（UFS），为一个或者多个容器提供访问，数据卷设计的目的，在于数据的永久存储，它完全独立于容器的生存周期，因此，docker 不会在容器删除时删除其挂载的数据卷，也不会存在类似的垃圾收集机制，对容器引用的数据卷进行处理，同一个数据卷可以只支持多个容器的访问。

数据卷的特点：

数据卷在容器启动时初始化，如果容器使用的镜像在挂载点包含了数据，这些数据会被拷贝到新初始化的数据卷中
数据卷可以在容器之间共享和重用
可以对数据卷里的内容直接进行修改
数据卷的变化不会影像镜像的更新
卷会一直存在，即使挂载数据卷的容器已经被删除

1、为容器添加数据卷

docker run -v /datavolume:/data -it centos /bin/bash
# 注：~/datavolume 为宿主机目录，/data 为 docker 启动的 volume 容器的里的目录,这样在宿主机的/datavolume 目录下创建的数据就会同步到容器的/data 目录下

（1）为数据卷添加访问权限 
docker run --name volume1 -v ~/datavolume1:/data:ro -itd centos /bin/bash

2、Docker 的数据卷容器共享

什么是数据卷容器：
命名的容器挂载数据卷，其他容器通过挂载这个容器实现数据共享，挂载数据卷的容器，就叫做数据卷容器

# 挂载数据卷容器的方法 
docker run --volumes-from [container name] 
例： 这个--volumes-from后面跟的是容器的名称。
docker run --name data-volume -itd volume（volume 这个镜像是上面创建的带两个数据卷
/datavolume3 和/ddatavolume6 的镜像）

docker run --name data-volume2 --volumes-from data-volume -itd centos /bin/bash

3、docker 数据卷的备份和还原

# 数据备份方法：

docker run --volumes-from [镜像--name名字] -v $(pwd):/backup [镜像名称] tar czvf /backup/[包名称].tar [container data volume]

例子： 
docker run --volumes-from data-volume2 -v /root/backup:/backup --name datavolume-copy centos tar zcvf /backup/data-volume2.tar.gz /datavolume6

docker run -tid --rm --volumes-from appname-minio4-1 -v $(pwd):/backup minio/minio:latest tar cvf /backup/backup.tar /data/minio/data4
 

# 数据还原方法： 
docker run --volumes-from [container name] -v $(pwd):/backup centos tar xzvf /backup/backup.tar.gz [container data volume]

例： 
docker exec -it data-volume2 /bin/bash 
cd /datavolume6 
rm -rf lucky.txt 
 
docker run --volumes-from data-volume2 -v /root/backup/:/backup centos tar zxvf 
/backup/data-volume2.tar.gz -C /datavolume6 
 
docker exec -it data-volum2 /bin/bash 
cd /datavolum6 
# 可以看到还原后的数据

七、docker 容器的网络模式

docker run 创建 docker 容器时，可以用–net 选项指定容器的网络模式，Docker 有以下 4 种网络模式：

bridge 模式：使–net =bridge 指定，默认设置；

host 模式：使–net =host 指定；

none 模式：使–net =none 指定；

container 模式：使用–net =container:NAME orID 指定。

1、安装网桥管理工具：

1
2
3

yum install bridge-utils -y 

brctl show 可以查看到有一个 docker0 的网桥设备，下面有很多接口，每个接口都表示一个启动的docker 容器，因为我在 docker 上启动了很多容器，所以 interfaces 较多

2、 docker link 设置网络别名

可以给容器起一个代号，这样可以直接以代号访问，避免了容器重启 ip 变化带来的问题 –link

docker run --link=[CONTAINER_NAME]:[ALIAS] [IMAGE][COMMAND] 

例： 
1.启动一个 test3 容器 
docker run --name test3 -itd inter-image /bin/bash 
 
 
2.启动一个 test5 容器，--link 做链接，那么当我们重新启动 test3 容器时，就算 ip 变了，也没关系，
我们可以在 test5 上 ping 别名 webtest 
docker run --name test5 -itd --link=test3:webtest inter-image /bin/bash 
 
3.test3 和 test5 的 ip 分别是 172.17.0.22 和 172.17.0.24 
 
4.重启 test3 容器 
docker restart test3 
发现 ip 变成了 172.17.0.25 
 
5.进入到 test5 容器 
docker exec -it test5 /bin/bash 
 
ping test3 容器的 ip 别名 webtest 可以 ping 通，尽管 test3 容器的 ip 变了也可以通

3、none 模式

Docker 网络 none 模式是指创建的容器没有网络地址，只有 lo 网卡

docker run -itd --name none --net=none --privileged=true centos

docker exec -it none /bin/bash


[root@05dbf3f2daaf /]# ip addr 
#只有本地 lo 地址 
 
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

4、container 模式

简单来说，指定一个已存在的容器，复制他的网络模式。

Docker 网络 container 模式是指，创建新容器的时候，通过–net container 参数，指定其和已经存在的某个容器共享一个 Network Namespace。

#和已经存在的 none 容器共享网络
[root@master1 ~]# docker run --name container2 --net=container:none -it --privileged=true centos

[root@05dbf3f2daaf /]# ip addr
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

5、 bridge 模式

默认选择 bridge 的情况下，容器启动后会通过 DHCP 获取一个地址

# 创建桥接网络
[root@master1~]# docker run --name bridge -it --privileged=true centos bash

[root@a131580fb605 /]# ip addr
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
64: eth0@if65: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group 
default 
 link/ether 02:42:ac:11:00:0d brd ff:ff:ff:ff:ff:ff link-netnsid 0
 inet 172.17.0.13/16 brd 172.17.255.255 scope global eth0
 valid_lft forever preferred_lft forever

4、host 模式

Docker 网络 host 模式是指共享宿主机的网络

1 2	`# 共享宿主机网络 [root@master1~]# docker run --name host -it --net=host --privileged=true centos bash`

docker 资源配额

Docker 通过 cgroup 来控制容器使用的资源限制，可以对 docker 限制的资源包括 CPU、内存、磁盘

1、指定 docker 容器可以使用的 cpu 份额

# 说白了，给他一个弹性的加权值，多个容器会进行分抢cup份额，权重越高，占用份额越多
docker run -it --cpu-shares 1024 centos /bin/bash

# CPU shares (relative weight) 在创建容器时指定容器所使用的 CPU 份额值。cpu-shares 的值不能保证可以获得 1 个 vcpu 或者多少 GHz 的 CPU 资源，仅仅只是一个弹性的加权值。

例：两个容器 A、B 的 cpu 份额分别为 1000 和 500，结果会怎么样？

**情况 1：**A 和 B 正常运行，占用同一个 CPU，在 cpu 进行时间片分配的时候，容器 A 比容器 B 多一倍

的机会获得 CPU 的时间片。

**情况 2：**分配的结果取决于当时其他容器的运行状态。比如容器 A 的进程一直是空闲的，那么容器 B是可以获取比容器 A 更多的 CPU 时间片的；比如主机上只运行了一个容器，即使它的 cpu 份额只有50，它也可以独占整个主机的 cpu 资源。

cgroups 只在多个容器同时争抢同一个 cpu 资源时，cpu 配额才会生效。因此，无法单纯根据某个容器的 cpu 份额来确定有多少 cpu 资源分配给它，资源分配结果取决于同时运行的其他容器的 cpu 分配和容器中进程运行情况

例 1：给容器实例分配 512 权重的 cpu 使用份额

参数： –cpu-shares 512

[root@master1 ~]# docker run -it --cpu-shares 512 centos /bin/bash 

[root@df176dd75bd4 /]# cat /sys/fs/cgroup/cpu/cpu.shares
#查看结果： 
512

注：稍后，我们启动多个容器，测试一下是不是只能使用 512 份额的 cpu 资源。单独一个容器，看不出来使用的 cpu 的比例。因没有 docker 实例同此 docker 实例竞争。

总结：

通过-c 设置的 cpu share 并不是 CPU 资源的绝对数量，而是一个相对的权重值。某个容器最终能分配到的 CPU 资源取决于它的 cpu share 占所有容器 cpu share 总和的比例。通过 cpu share 可以设置容器使用 CPU 的优先级

比如在 host 中启动了两个容器：

1
2
3

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。

2、CPU core 核心控制

1	`docker run -itd --name docker10 --cpuset-cpus 0,1 --cpu-shares 512 centos /bin/bash`

参数：–cpuset 可以绑定 CPU

对多核 CPU 的服务器，docker 还可以控制容器运行限定使用哪些 cpu 内核和内存节点，即使用–cpuset-cpus 和–cpuset-mems 参数。对具有 NUMA 拓扑（具有多 CPU、多内存节点）的服务器尤其有用，可以对需要高性能计算的容器进行性能最优的配置。如果服务器只有一个内存节点，则–cpuset-mems 的配置基本上不会有明显效果。

扩展：

服务器架构一般分： SMP、NUMA、MPP 体系结构介绍

从系统架构来看，目前的商用服务器大体可以分为三类：

即对称多处理器结构(SMP ： Symmetric Multi-Processor) 例： x86 服务器，双路服务器。主板上有两个物理 cpu
非一致存储访问结构 (NUMA ： Non-Uniform Memory Access) 例： IBM 小型机pSeries 690
海量并行处理结构 (MPP ： Massive ParallelProcessing) 。例：大型机 Z14

知识点：

CPU 配额控制参数的混合使用

容器 A 和容器 B 配置上 cpuset-cpus 值并都绑定到同一个 cpu 上，然后同时抢占 cpu 资源，就可以

看出效果了。

例 1：测试 cpu-shares 和 cpuset-cpus 混合使用运行效果，就需要一个压缩力测试工具 stress 来让

容器实例把 cpu 跑满

如何把 cpu 跑满？

如何把 4 核心的 cpu 中第一和第三核心跑满？可以运行 stress，然后使用 taskset 绑定一下 cpu。

先扩展：stress 命令

概述：linux 系统压力测试软件 Stress 。

[root@master1 ~]# yum install -y epel-release 
[root@master1 ~]# yum install stress -y 

stress 参数解释 
-? 显示帮助信息 
-v 显示版本号 
-q 不显示运行信息 
-n 显示已完成的指令情况 
-t --timeout N 指定运行 N 秒后停止 
--backoff N 等待 N 微妙后开始运行 
-c 产生 n 个进程 ：每个进程都反复不停的计算随机数的平方根，测试 cpu 
-i 产生 n 个进程 ：每个进程反复调用 sync()，sync()用于将内存上的内容写到硬盘上，测试磁盘 io 
-m --vm n 产生 n 个进程,每个进程不断调用内存分配 malloc（）和内存释放 free（）函数 ，测试内存 
--vm-bytes B 指定 malloc 时内存的字节数 （默认 256MB） 
--vm-hang N 指定在 free 栈的秒数 
-d --hadd n 产生 n 个执行 write 和 unlink 函数的进程 
-hadd-bytes B 指定写的字节数 
--hadd-noclean 不 unlink 
注：时间单位可以为秒 s，分 m，小时 h，天 d，年 y，文件大小单位可以为 K，M，G 
 
例 1：产生 2 个 cpu 进程，2 个 io 进程，20 秒后停止运行 
[root@master1]# stress -c 2 -i 2 --verbose --timeout 20s 
#如果执行时间为分钟，改 20s 为 1m 
 
查看：
top

例 1：测试 cpuset-cpus 和 cpu-shares 混合使用运行效果，就需要一个压缩力测试工具 stress 来让容器实例把 cpu 跑满。 当跑满后，会不会去其他 cpu 上运行。 如果没有在其他 cpu 上运行，说明cgroup 资源限制成功。 
实例 3：创建两个容器实例:docker10 和 docker20。 让 docker10 和 docker20 只运行在 cpu0 和
cpu1 上，最终测试一下 docker10 和 docker20 使用 cpu 的百分比。


测试 1： 进入 docker10，使用 stress 测试进程是不是只在 cpu0,1 上运行： 
[root@master1 ~]# docker run -it --name docker10 centos   /bin/bash 
[root@d1a431815090 /]# yum install -y epel-release #安装 epel 扩展源 
[root@d1a431815090 /]# yum install stress -y #安装 stress 命令 
[root@d1a431815090 /]# stress -c 2 -v -t 10m #运行 2 个进程，把两个 cpu 占满 
在物理机另外一个虚拟终端上运行 top 命令，按 1 快捷键，查看每个 cpu 使用情况：

 
测试 2： 然后进入 docker20，使用 stress 测试进程是不是只在 cpu0,1 上运行，且 docker20 上运行的 stress 使用 cpu 百分比是 docker10 的 2 倍 
[root@master1 ~]# docker run -it --name docker20 centos /bin/bash 
[root@d1a431815090 /]# yum install -y epel-release #安装 epel 扩展源 
[root@d1a431815090 /]# yum install stress -y 
[root@f24e75bca5c0 /]# stress -c 2 -v -t 10m 
 
在另外一个虚拟终端上运行 top 命令，按 1 快捷键，查看每个 cpu 使用情况：
注：两个容器只在 cpu0,1 上运行，说明 cpu 绑定限制成功。而 docker20 是 docker10 使用 cpu 的 2倍。说明--cpu-shares 限制资源成功。

3、docker 容器控制内存

Docker 提供参数-m, –memory=””限制容器的内存使用量。

例 1：允许容器使用的内存上限为 128M： 
[root@master1 ~]# docker run -it -m 128m centos 
查看： 

[root@40bf29765691 /]# cat /sys/fs/cgroup/memory/memory.limit_in_bytes 
134217728 

注：也可以使用 tress 进行测试，到现在，我可以限制 docker 实例使用 cpu 的核心数和权重，可以限制内存大小。 

例 2：创建一个 docker，只使用 2 个 cpu 核心，只能使用 128M 内存 
[root@master1 ~]# docker run -it --cpuset-cpus 0,1 -m 128m centos

4、docker 容器控制 IO

[root@master1 ~]# docker run --help | grep write-b 
 --device-write-bps value Limit write rate (bytes per second) to a device (default []) 
#限制此设备上的写速度（bytes per second），单位可以是 kb、mb 或者 gb。 
--device-read-bps value #限制此设备上的读速度（bytes per second），单位可以是 kb、mb 或
者 gb。
 
情景：防止某个 Docker 容器吃光你的磁盘 I / O 资源
 
例 1：限制容器实例对硬盘的最高写入速度设定为 2MB/s。 
--device 参数：将主机设备添加到容器 
[root@master1 ~]# mkdir -p /var/www/html/ 
[root@master1 ~]# docker run -it -v /var/www/html/:/var/www/html --device /dev/sda:/dev/sda --device-write-bps /dev/sda:2mb centos /bin/bash
 
[root@bd79042dbdc9 /]# time dd if=/dev/sda of=/var/www/html/test.out bs=2M count=50 oflag=direct,nonblock
 
注：dd 参数： 
direct：读写数据采用直接 IO 方式，不走缓存。直接从内存写硬盘上。 
nonblock：读写数据采用非阻塞 IO 方式，优先写 dd 命令的数据 
50+0 records in 
50+0 records out 
52428800 bytes (52 MB) copied, 50.1831 s, 2.0 MB/s 
 
real 0m50.201s 
user 0m0.001s 
sys 0m0.303s 
注： 发现 1 秒写 2M。 限制成功。

5、docker 容器运行结束自动释放资源

[root@master1 ~]# docker run --help | grep rm 
 --rm 参数： Automatically remove the container when it exits 
作用：当容器命令运行结束后，自动删除容器，自动释放资源 


例： 
[root@master1 ~]# docker run -it --rm --name xianchao centos sleep 6 
物理上查看： 
[root@master1 ~]# docker ps -a | grep xianchao 

6c75a9317a6b centos "sleep 6" 6 seconds ago Up 4 

seconds mk 

等 5s 后，再查看： 
[root@master1 ~]# docker ps | grep xianchao #自动删除了

八、docker 私有镜像仓库 harbor

Harbor 介绍

Docker 容器应用的开发和运行离不开可靠的镜像管理，虽然 Docker 官方也提供了公共的镜像仓库，但是从安全和效率等方面考虑，部署我们私有环境内的 Registry 也是非常必要的。Harbor 是由 VMware公司开源的企业级的 Docker Registry 管理项目，它包括权限管理(RBAC)、LDAP、日志审核、管理界面、自我注册、镜像复制和中文支持等功能。

官网地址：https://github.com/goharbor/harbor

安装 harbor 的机器，主机名设置成 harbor
机器需要的内存至少要 2G，我分配的是 4G
机器 ip：192.168.40.181
4vCPU/4G 内存/100G 硬盘

1、安装证书：

为 Harbor 自签发证书 
[root@192 ~]# hostnamectl set-hostname harbor && bash
[root@harbor ~]# mkdir /data/ssl -p
[root@harbor ~]# cd /data/ssl/
生成 ca 证书：
[root@harbor ssl]# openssl genrsa -out ca.key 3072

#生成一个 3072 位的 key，也就是私钥
 [root@harbor ssl]# openssl req -new -x509 -days 3650 -key ca.key -out ca.pem

#生成一个数字证书 ca.pem，3650 表示证书的有效时间是 3 年，按箭头提示填写即可，没有箭头标注的为
空：
Country Name (2 letter code) [XX]:CH
State or Province Name (full name) []:BJ
Locality Name (eg, city) [Default City]:BJ
Organization Name (eg, company) [Default Company Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (eg, your name or your server's hostname) []:
Email Address []:

生成域名的证书： 
[root@harbor ssl]# openssl genrsa -out harbor.key 3072
#生成一个 3072 位的 key，也就是私钥

[root@harbor ssl]# openssl req -new -key harbor.key -out harbor.csr
#生成一个证书请求，一会签发证书时需要的，标箭头的按提示填写，没有箭头标注的为空
-----
Country Name (2 letter code) [XX]:CH
State or Province Name (full name) []:BJ
Locality Name (eg, city) [Default City]:BJ
Organization Name (eg, company) [Default Company Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (eg, your name or your server's hostname) []:harbor
Email Address []:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:


签发证书：
[root@harbor ssl]# openssl x509 -req -in harbor.csr -CA ca.pem -CAkey ca.key -CAcreateserial -out harbor.pem -days 3650

显示如下，说明证书签发好了：
signature ok
subject=/C=CH/ST=BJ/L=BJ/0=Default Company Ltd/CN=harborGetting CA Private Key

2、安装 Harbor

需要docker环境。

#创建安装目录
[root@harbor ssl]# mkdir /data/install -p && cd /data/install/

##安装 harbor
/data/ssl 目录下有如下文件：
ca.key ca.pem ca.srl harbor.csr harbor.key harbor.pem
[root@harbor install]# cd /data/install/

#把 harbor 的离线包 harbor-offline-installer-v2.3.0-rc3.tgz 上传到这个目录，离线包在课件里提供了
#下载 harbor 离线包的地址：
https://github.com/goharbor/harbor/releases/tag/

解压：
[root@harbor install]# tar zxvf harbor-offline-installer-v2.3.0-rc3.tgz
[root@harbor install]# cd harbor
[root@harbor harbor]# cp harbor.yml.tmpl harbor.yml
[root@harbor harbor]# vim harbor.yml

修改配置文件：
hostname: harbor 
#修改 hostname，跟上面签发的证书域名保持一致
hostname: harbor
#协议用 https
certificate: /data/ssl/harbor.pem
private_key: /data/ssl/harbor.key
#邮件和 ldap 不需要配置，在 harbor 的 web 界面可以配置
#其他配置采用默认即可
#修改之后保存退出
注：harbor 默认的账号密码：admin/Harbor12345


=================================================================================
#安装 docker-compose
#上传课件里的 docker-compose-Linux-x86_64 文件到 harbor 机器。这一步不需要联网下载镜像了，省事
[root@harbor harbor]# mv docker-compose-Linux-x86_64.64 /usr/bin/docker-compose
[root@harbor harbor]# chmod +x /usr/bin/docker-compose
注： docker-compose 项目是 Docker 官方的开源项目，负责实现对 Docker 容器集群的快速编排。
Docker-Compose 的工程配置文件默认为 docker-compose.yml，Docker-Compose 运行目录下的必要有一个
docker-compose.yml。docker-compose 可以管理多个 docker 实例。
安装 harbor 需要的离线镜像包 docker-harbor-2-3-0.tar.gz 在课件，可上传到 harbor 机器，通过
docker load -i 解压
[root@harbor install]# docker load -i docker-harbor-2-3-0.tar.gz 
[root@harbor install]# cd /data/install/harbor

# 配置私有仓库地址
[root@master1 ~]# vim /etc/docker/daemon.json

{
 "registry-mirrors":["https://rsbud4vc.mirror.aliyuncs.com","https://registry.docker-cn.com","https://docker.mirrors.ustc.edu.cn","https://dockerhub.azk8s.cn","http://hub-mirror.c.163.com","http://qtid6917.mirror.aliyuncs.com", "https://rncxm540.mirror.aliyuncs.com"],
 "insecure-registries": ["192.168.162.30","harbor"],
 "exec-opts": ["native.cgroupdriver=systemd"]
} 

#注意：
#配置新增加了一行内容如下：
"insecure-registries":["192.168.162.30"], 
#上面增加的内容表示我们内网访问 harbor 的时候走的是 http，192.168.162.30 是安装 harbor 机器的 ip

# 修改配置之后使配置生效：
[root@master1 ~]# systemctl daemon-reload && systemctl restart docker

# 查看 docker 是否启动成功
[root@master1 ~]# systemctl status docker
#显示如下，说明启动成功：
Active: active (running) 

# 安装
[root@harbor harbor]# ./install.sh

#在自己电脑修改 hosts 文件
#在 hosts 文件添加如下一行，然后保存即可,ip写你本机的
192.168.162.30 harbor

# 虚拟机也需要配置一下
vim /etc/hosts
192.168.162.30 harbor

扩展：
如何停掉 harbor：
[root@harbor harbor]# cd /data/install/harbor
[root@harbor harbor]# docker-compose stop 

如何启动 harbor：
[root@harbor harbor]# cd /data/install/harbor
[root@harbor harbor]# docker-compose start
如果 docker-compose start 启动 harbor 之后，还是访问不了，那就需要重启虚拟机

3、Harbor 图像化界面使用说明

在浏览器输入：

https://harbor

账号：admin

密码：Harbor12345

4、测试使用 harbor 私有镜像仓库

#登录 harbor：
[root@master1]# docker login 192.168.162.30
Username：admin
Password: Harbor12345
输入账号密码之后看到如下，说明登录成功了：
Login Succeeded

# 错误看下面

#导入 tomcat 镜像，tomcat.tar.gz 在课件里
[root@master1 ~]# docker load -i tomcat.tar.gz
#把 tomcat 镜像打标签，这里需要在horbor上新建一个项目test
[root@master1 ~]# docker tag tomcat:latest 192.168.162.30/test/tomcat:v1
# 执行上面命令就会把 192.168.40.181/test/tomcat:v1 上传到 harbor 里的 test 项目下

[root@master1 ~]# docker push 192.168.162.30/test/tomcat:v1
执行上面命令就会把 192.168.40.181/test/tomcat:v1 上传到 harbor 里的 test 项目下



 # 从 harbor 仓库下载镜像 
# 在 master1 机器上删除镜像
[root@master1 ~]# docker rmi -f 192.168.162.30/test/tomcat:v1
# 拉取镜像
[root@master1 ~]#docker pull 192.168.162.30/test/tomcat:v1

Error response from daemon: Get “https://192.168.162.30:443/v2/“: Get “https://harbor/service/token?account=admin&client_id=docker&offline_token=true&service=harbor-registry“: dial tcp: lookup harbor on 114.114.114.114:53: no such host

解决：

修改 /etc/hosts

vim /etc/hosts
192.168.162.30 harbor

九、配置阿里云的yum源

epel工具源：https://developer.aliyun.com/mirror/epel?spm=a2c6h.13651102.0.0.3e221b11oIlZCb

centos阿里云源：https://developer.aliyun.com/mirror/centos?spm=a2c6h.13651102.0.0.3e221b11oIlZCb

mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup

# centos-8配置
wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo

# centos-7配置
wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo

# 刷新yum源 
yum clean all && yum makecache

docker相关

#linux #docker #containerd

Dockers核心技术精讲

http://blog.kjiang.vip/posts/1950070030.html

作者

江

发布于

2025年5月30日

许可协议

NPS内网穿透安装上一篇

Dockers核心技术精讲

一、Dockers核心技术精讲

二、Docker的概述

1、背景

2、docker 的优点

3、docker 缺点

4、docker安装

4.1 安装基础环境

4.2 安装Docker-ce

4.3 开启包转发功能和修改内核参数

4.4 开启云加速器

4.5 实战nginx

5、docker问题：

Docker 安装后出现：WARNING: bridge-nf-call-iptables is disabled 的解决办法：

三、containerd 容器概述

1、Containerd 和 Docker 之间的关系

2、Containerd 在容器生态中扮演的角色

2-1 K8S 为什么要放弃使用 Docker 作为容器运行时，而使用 containerd 呢？

3、containerd 安装和配置

4、containerd使用

5、docker 的镜像和 containerd 镜像通用吗？

四、Dockerfile语法详解

五、将编译后的文件进行构建

1、将go代码进行构建镜像

2、将java代码构建成镜像

六、Docker 数据卷管理

1、为容器添加数据卷

2、Docker 的数据卷容器共享

3、docker 数据卷的备份和还原

七、docker 容器的网络模式

1、安装网桥管理工具：

2、 docker link 设置网络别名

3、none 模式

4、container 模式

5、 bridge 模式

4、host 模式

docker 资源配额

1、指定 docker 容器可以使用的 cpu 份额

2、CPU core 核心控制

3、docker 容器控制内存

4、docker 容器控制 IO

5、docker 容器运行结束自动释放资源

八、docker 私有镜像仓库 harbor

1、安装证书：

2、安装 Harbor

3、Harbor 图像化界面使用说明

4、测试使用 harbor 私有镜像仓库

5、docker login 192.168.162.30 错误问题

九、配置阿里云的yum源