lyfGeek

Kubernetes ~ k8s 从入门到入坑。

文章目录

- Kubernetes ~ k8s 从入门到入坑。
- - 1. Kubernetes 介绍。
  - - - 1.1 应用部署方式演变。
      - 1.2 kubernetes 简介。
      - 1.3 kubernetes 组件。
      - 1.4 kubernetes 概念。
  - 2. kubernetes 集群环境搭建。
  - - - 2.1 前置知识点。
      - 2.2 kubeadm 部署方式介绍。
      - 2.3 安装要求。
      - 2.4 最终目标。
      - 2.5 准备环境。
      - 2.6 环境初始化。
      - 2.6.1 检查操作系统的版本。
        
        2.6.2 主机名解析。
        
        2.6.3 时间同步。
        
        2.6.4 禁用 iptables 和 firewalld 服务。
        
        2.6.5 禁用 selinux。
        
        2.6.6 禁用 swap 分区。
        
        2.6.7 修改 linux 的内核参数。
        
        2.6.8 配置 ipvs 功能。
        
        2.6.9 安装 docker。
        
        2.6.10 安装 Kubernetes 组件。
        
        2.6.11 准备集群镜像。
        
        2.6.12 集群初始化。
        
        2.6.13 安装网络插件，只在 master 节点操作即可。
        
        2.6.14 使用 kubeadm reset 重置集群。
        
        2.6.15 重启 kubelet 和 docker。
        
        2.6.16 kubeadm 中的命令。
      - 2.7 集群测试。
      - 2.7.1 创建一个 nginx 服务。
        
        2.7.2 暴露端口。
        
        2.7.3 查看服务。
        
        2.7.4 查看 pod。
  - 3. 资源管理。
  - - - 3.1 资源管理介绍。
      - 3.2 YAML 语言介绍。
      - 3.3 资源管理方式。
      - 3.3.1 命令式对象管理。
        
        3.3.2 命令式对象配置。
        
        3.3.3 声明式对象配置。
  - 4. 实战入门。
  - - - 4.1 Namespace。
      - 4.1.1 查看。
        
        4.1.2 创建。
        
        4.1.3 删除。
        
        4.1.4 配置方式。
      - 4.2 Pod。
      - 4.2.1 创建并运行。
        
        4.2.2 查看 pod 信息。
        
        4.2.3 访问 Pod。
        
        4.2.4 删除指定 Pod。
        
        4.2.5 配置操作。
      - 4.3 Label。
      - 4.3.1 命令方式。
        
        4.3.2 配置方式。
      - 4.4 Deployment。
      - 4.4.1 命令操作。
        
        4.4.2 配置操作。
      - 4.5 Service。
      - 4.5.1 创建集群内部可访问的 Service。
        
        4.5.2 创建集群外部也可访问的 Service。
        
        4.5.3 删除 Service。
        
        4.5.4 配置方式。
  - 5. Pod 详解。
  - - - 5.1 Pod 介绍。
      - 5.1.1 Pod 结构。
        
        5.1.2 Pod 定义。
      - 5.2 Pod 配置。
      - 5.2.1 基本配置。
        
        5.2.2 镜像拉取。
        
        5.2.3 启动命令。
        
        5.2.4 环境变量。
        
        5.2.5 端口设置。
        
        5.2.6 资源配额。
      - 5.3 Pod 生命周期。
      - 5.3.1 创建和终止。
        
        5.3.2 初始化容器。
        
        5.3.3 钩子函数。
        
        5.3.4 容器探测。
        
        5.3.5 重启策略。
      - 5.4 Pod 调度。
      - 5.4.1 定向调度。
        
        - **NodeName**。
        
        - **NodeSelector**。
        
        5.4.2 亲和性调度。
        
        - **NodeAffinity**。
        
        - **PodAffinity**。
        
        - **PodAntiAffinity**。
        
        5.4.3 污点和容忍。
        
        - **污点（Taints）**。
        
        - **容忍（Toleration）**。
  - 6. Pod 控制器详解。
  - - - 6.1 Pod 控制器介绍。
      - 6.2 ReplicaSet（RS）。
      - **扩缩容**。
        
        **镜像升级**。
      - 6.3 Deployment（Deploy）。
      - 6.3.1 创建 deployment。
        
        6.3.2 扩缩容。
        
        **镜像更新**。
        
        - 重建更新。
        
        - 滚动更新。
        
        6.3.3 版本回退。
        
        6.3.4 金丝雀发布。
      - 6.4 Horizontal Pod Autoscaler（HPA）。
      - 6.4.1 安装 metrics-server。
        
        6.4.2 准备 deployment 和 service。
        
        6.4.3 部署 HPA。
        
        6.4.4 测试。
      - 6.5 DaemonSet（DS）。
      - 6.6 Job。
      - 6.7 CronJob（CJ）。
      - StatefulSet。
  - 7. Service 详解。
  - - - 7.1 Service 介绍。
      - 7.1.1 userspace 模式。
      - 7.1.2 iptables 模式。
        
        7.1.3 ipvs 模式。
      - 7.2 Service 类型。
      - 7.3 Service 使用。
      - 7.3.1 实验环境准备。
        
        7.3.2 ClusterIP 类型的 Service。
        
        7.3.3 Endpoint。
        
        7.3.4 HeadLiness 类型的 Service。
        
        7.3.5 NodePort 类型的 Service。
        
        7.3.6 LoadBalancer 类型的 Service。
        
        7.3.7 ExternalName 类型的 Service。
      - 7.4 Ingress 介绍。
      - 7.5 Ingress 使用。
      - 7.5.1 环境准备 ~ 搭建 ingress 环境。
        
        7.5.2 准备 service 和 pod。
        
        7.5.2 Http 代理。
        
        7.5.3 Https 代理。
  - 8. 数据存储。
  - 9. 安全认证。
  - 10. dashboard。

1. Kubernetes 介绍。

1.1 应用部署方式演变。

在部署应用程序的方式上，主要经历了三个时代。

传统部署：互联网早期，会直接将应用程序部署在物理机上。

优点：简单，不需要其它技术的参与。

缺点：不能为应用程序定义资源使用边界，很难合理地分配计算资源，而且程序之间容易产生影响。

虚拟化部署：可以在一台物理机上运行多个虚拟机，每个虚拟机都是独立的一个环境。

优点：程序环境不会相互产生影响，提供了一定程度的安全性。

缺点：增加了操作系统，浪费了部分资源。

容器化部署：与虚拟化类似，但是共享了操作系统。

优点。
可以保证每个容器拥有自己的文件系统、CPU、内存、进程空间等。
运行应用程序所需要的资源都被容器包装，并和底层基础架构解耦。
容器化的应用程序可以跨云服务商、跨 Linux 操作系统发行版进行部署。

容器化部署方式给带来很多的便利，但是也会出现一些问题，比如说。

一个容器故障停机了，怎么样让另外一个容器立刻启动去替补停机的容器。
当并发访问量变大的时候，怎么样做到横向扩展容器数量。

这些容器管理的问题统称为容器编排问题，为了解决这些容器编排问题，就产生了一些容器编排的软件。

Swarm：Docker 自己的容器编排工具。
Mesos：Apache 的一个资源统一管控的工具，需要和 Marathon 结合使用。
Kubernetes：Google 开源的的容器编排工具。

1.2 kubernetes 简介。

kubernetes，是一个全新的基于容器技术的分布式架构领先方案，是谷歌严格保密十几年的秘密武器 —— Borg 系统的一个开源版本，于 2014 年 9 月发布第一个版本，2015 年 7 月发布第一个正式版本。

kubernetes 的本质是一组服务器集群，它可以在集群的每个节点上运行特定的程序，来对节点中的容器进行管理。目的是实现资源管理的自动化，主要提供了如下的主要功能：

自我修复：一旦某一个容器崩溃，能够在 1 秒中左右迅速启动新的容器。
弹性伸缩：可以根据需要，自动对集群中正在运行的容器数量进行调整。
服务发现：服务可以通过自动发现的形式找到它所依赖的服务。
负载均衡：如果一个服务起动了多个容器，能够自动实现请求的负载均衡。
版本回退：如果发现新发布的程序版本有问题，可以立即回退到原来的版本。
存储编排：可以根据容器自身的需求自动创建存储卷。

1.3 kubernetes 组件。

一个 kubernetes 集群主要是由控制节点（master）、工作节点（node）构成，每个节点上都会安装不同的组件。

master：集群的控制平面，负责集群的决策（管理）。

ApiServer：资源操作的唯一入口，接收用户输入的命令，提供认证、授权、API 注册和发现等机制。
Scheduler：负责集群资源调度，按照预定的调度策略将 Pod 调度到相应的 node 节点上。
ControllerManager：负责维护集群的状态，比如程序部署安排、故障检测、自动扩展、滚动更新等。
Etcd：负责存储集群中各种资源对象的信息。

node：集群的数据平面，负责为容器提供运行环境（干活）。

Kubelet：负责维护容器的生命周期，即通过控制 docker，来创建、更新、销毁容器。
KubeProxy：负责提供集群内部的服务发现和负载均衡。
Docker：负责节点上容器的各种操作。

下面，以部署一个 Nginx 服务来说明 kubernetes 系统各个组件调用关系。

首先要明确，一旦 kubernetes 环境启动之后，master 和 node 都会将自身的信息存储到 etcd 数据库中。
一个 Nginx 服务的安装请求会首先被发送到 master 节点的 apiServer 组件。
apiServer 组件会调用 scheduler 组件来决定到底应该把这个服务安装到哪个 node 节点上。
在此时，它会从 etcd 中读取各个 node 节点的信息，然后按照一定的算法进行选择，并将结果告知 apiServer。
apiServer 调用 controller-manager 去调度 node 节点安装 Nginx 服务。
kubelet 接收到指令后，会通知 docker，然后由 docker 来启动一个 Nginx 的 pod。
pod 是 kubernetes 的最小操作单元，容器必须跑在 pod 中。
至此，一个 Nginx 服务就运行了，如果需要访问 Nginx，就需要通过 kube-proxy 来对 pod 产生访问的代理。
这样，外界用户就可以访问集群中的 Nginx 服务了。

1.4 kubernetes 概念。

Master：集群控制节点，每个集群需要至少一个 master 节点负责集群的管控。

Node：工作负载节点，由 master 分配容器到这些 node 工作节点上，然后 node 节点上的 docker 负责容器的运行。

Pod：kubernetes 的最小控制单元，容器都是运行在 pod 中的，一个 pod 中可以有 1 个或者多个容器。

Controller：控制器，通过它来实现对 pod 的管理，比如启动 pod、停止 pod、伸缩 pod 的数量等等。

Service：pod 对外服务的统一入口，下面可以维护者同一类的多个 pod。

Label：标签，用于对 pod 进行分类，同一类 pod 会拥有相同的标签。（app:tom、app:tomcat）

NameSpace：命名空间，用来隔离 pod 的运行环境。（虚线）。

2. kubernetes 集群环境搭建。

https://www.yuque.com/fairy-era/yg511q/hg3u04

2.1 前置知识点。

目前生产部署 Kubernetes 集群主要有：

minikube：用于快速搭建单节点 kubernetes 的工具。
kubeadm。

Kubeadm 是一个 K8s 部署工具，提供 kubeadm init 和 kubeadm join，用于快速部署 Kubernetes 集群。

官方地址：https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm/。

二进制包。

从 github 下载发行版的二进制包，手动部署每个组件，组成 Kubernetes 集群。

Kubeadm 降低部署门槛，但屏蔽了很多细节，遇到问题很难排查。如果想更容易可控，推荐使用二进制包部署 Kubernetes 集群，虽然手动部署麻烦点，期间可以学习很多工作原理，也利于后期维护。

2.2 kubeadm 部署方式介绍。

kubeadm 是官方社区推出的一个用于快速部署 kubernetes 集群的工具，这个工具能通过两条指令完成一个 kubernetes 集群的部署：

创建一个 Master 节点 kubeadm init。
将 Node 节点加入到当前集群中$ kubeadm join 。

2.3 安装要求。

在开始之前，部署 Kubernetes 集群机器需要满足以下几个条件：

一台或多台机器，操作系统 CentOS7.x-86_x64。
硬件配置：2GB 或更多 RAM，2 个 CPU 或更多 CPU，硬盘 30GB 或更多。
集群中所有机器之间网络互通。
可以访问外网，需要拉取镜像。
禁止 swap 分区。

2.4 最终目标。

在所有节点上安装 Docker 和 kubeadm。
部署 Kubernetes Master。
部署容器网络插件。
部署 Kubernetes Node，将节点加入 Kubernetes 集群中。
部署 Dashboard Web 页面，可视化查看 Kubernetes 资源。

2.5 准备环境。

角色	IP 地址	组件
master01	192.168.142.150	docker，kubectl，kubeadm，kubelet
node01	192.168.142.151	docker，kubectl，kubeadm，kubelet
node02	192.168.142.152	docker，kubectl，kubeadm，kubelet

2.6 环境初始化。

2.6.1 检查操作系统的版本。

http://mirrors.163.com/.help/centos.html

# 此方式下安装 kubernetes 集群要求 Centos 版本要在 7.5 或之上。
[root@localhost ~]# cat /etc/redhat-release
CentOS Linux release 7.9.2009 (Core)

2.6.2 主机名解析。

为了方便集群节点间的直接调用，在这个配置一下主机名解析，企业中推荐使用内部 DNS 服务器。

vim /etc/hosts
# 主机名成解析 编辑三台服务器的 /etc/hosts 文件，添加下面内容。
192.168.142.150 localhost.localdomain.k8s.master
192.168.142.151 localhost.localdomain.k8s.node1
192.168.142.152 localhost.localdomain.k8s.node2

2.6.3 时间同步。

kubernetes 要求集群中的节点时间必须精确一直，这里使用 chronyd 服务从网络同步时间。

企业中建议配置内部的会见同步服务器。

# 启动 chronyd 服务。
[root@master ~]# systemctl start chronyd
[root@master ~]# systemctl enable chronyd
[root@master ~]# date

2.6.4 禁用 iptables 和 firewalld 服务。

kubernetes 和 docker 在运行的中会产生大量的 iptables 规则，为了不让系统规则跟它们混淆，直接关闭系统的规则。

# 关闭 firewalld 服务。
[root@localhost ~]# systemctl stop firewalld
[root@localhost ~]# systemctl disable firewalld
Removed symlink /etc/systemd/system/multi-user.target.wants/firewalld.service.
Removed symlink /etc/systemd/system/dbus-org.fedoraproject.FirewallD1.service.
[root@localhost ~]# systemctl stop iptables
Failed to stop iptables.service: Unit iptables.service not loaded.
[root@localhost ~]# systemctl disable iptables
Failed to execute operation: No such file or directory

2.6.5 禁用 selinux。

selinux 是 linux 系统下的一个安全服务，如果不关闭它，在安装集群中会产生各种各样的奇葩问题。

[root@localhost ~]# getenforce
Enforcing

vim /etc/selinux/config
# 编辑 /etc/selinux/config 文件，修改 SELINUX 的值为 disable。
# 注意修改完毕之后需要重启 linux 服务。
SELINUX=disabled



# This file controls the state of SELinux on the system.
# SELINUX= can take one of these three values:
#     enforcing - SELinux security policy is enforced.
#     permissive - SELinux prints warnings instead of enforcing.
#     disabled - No SELinux policy is loaded.
# SELINUX=enforcing
SELINUX=disabled
# SELINUXTYPE= can take one of three values:
#     targeted - Targeted processes are protected,
#     minimum - Modification of targeted policy. Only selected processes are protected. 
#     mls - Multi Level Security protection.
SELINUXTYPE=targeted

2.6.6 禁用 swap 分区。

swap 分区指的是虚拟内存分区，它的作用是物理内存使用完，之后将磁盘空间虚拟成内存来使用，启用 swap 设备会对系统的性能产生非常负面的影响，因此 kubernetes 要求每个节点都要禁用 swap 设备，但是如果因为某些原因确实不能关闭 swap 分区，就需要在集群安装过程中通过明确的参数进行配置说明。

# 编辑分区配置文件 /etc/fstab，注释掉 swap 分区一行。
# 注意修改完毕之后需要重启 linux 服务。
vim /etc/fstab
# 注释掉 /dev/mapper/centos-swap swap。
# /dev/mapper/centos-swap swap

[root@localhost ~]# vim /etc/fstab


#

#
# /etc/fstab
# Created by anaconda on Thu Dec  1 01:25:13 2022

#
# /etc/fstab
# Created by anaconda on Thu Dec  1 01:25:13 2022
#
# Accessible filesystems, by reference, are maintained under '/dev/disk'
# See man pages fstab(5), findfs(8), mount(8) and/or blkid(8) for more info
#
/dev/mapper/centos_localhost-root /                       xfs     defaults        0 0
UUID=c393aaa9-2e37-4fa2-8b32-e8b88af1e576 /boot                   xfs     defaults        0 0
/dev/mapper/centos_localhost-home /home                   xfs     defaults        0 0
#  /dev/mapper/centos_localhost-swap swap                    swap    defaults        0 0

2.6.7 修改 linux 的内核参数。

vim /etc/sysctl.d/kubernetes.comf

# 修改 linux 的内核参数，添加网桥过滤和地址转发功能。
# 编辑 /etc/sysctl.d/kubernetes.conf 文件，添加如下配置：
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
# 重新加载配置。
[root@master ~]# sysctl -p
# 加载网桥过滤模块。
[root@master ~]# modprobe br_netfilter
# 查看网桥过滤模块是否加载成功。
[root@localhost ~]# lsmod | grep br_netfilter
br_netfilter           22256  0 
bridge                151336  1 br_netfilter

2.6.8 配置 ipvs 功能。

在 Kubernetes 中 Service 有两种带来模型，一种是基于 iptables 的，一种是基于 ipvs 的两者比较的话，ipvs 的性能明显要高一些，但是如果要使用它，需要手动载入 ipvs 模块。

# 安装 ipset 和 ipvsadm。
[root@master ~]# yum install ipset ipvsadm -y
# 添加需要加载的模块写入脚本文件。
[root@master ~]# cat < /etc/sysconfig/modules/ipvs.modules
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
EOF
# 为脚本添加执行权限。
[root@master ~]# chmod +x /etc/sysconfig/modules/ipvs.modules
# 执行脚本文件。
[root@master ~]# /bin/bash /etc/sysconfig/modules/ipvs.modules
# 查看对应的模块是否加载成功。
[root@localhost ~]# lsmod | grep -e ip_vs -e nf_conntrack_ipv4
nf_conntrack_ipv4      15053  0 
nf_defrag_ipv4         12729  1 nf_conntrack_ipv4
ip_vs_sh               12688  0 
ip_vs_wrr              12697  0 
ip_vs_rr               12600  0 
ip_vs                 145458  6 ip_vs_rr,ip_vs_sh,ip_vs_wrr
nf_conntrack          139264  2 ip_vs,nf_conntrack_ipv4
libcrc32c              12644  3 xfs,ip_vs,nf_conntrack

重启。

[root@localhost ~]# getenforce
Disabled
[root@localhost ~]# free -m
              total        used        free      shared  buff/cache   available
Mem:           1819         193        1451           9         174        1476
Swap:             0           0           0
[root@localhost ~]#

2.6.9 安装 docker。

https://docs.docker.com/engine/install/centos/

sudo yum install docker-ce- docker-ce-cli- containerd.io docker-compose-plugin

18.06.3.ce-3.el7

sudo yum install docker-ce-18.06.3.ce-3.el7 docker-ce-cli-18.06.3.ce-3.el7 containerd.io docker-compose-plugin

yum clean all
yum makecache

# 切换镜像源。
[root@master ~]# wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo
# 查看当前镜像源中支持的 docker 版本。
[root@master ~]# yum list docker-ce --showduplicates
# 安装特定版本的 docker-ce。
# 必须指定 --setopt=obsoletes=0，否则 yum 会自动安装更高版本。
[root@master ~]# yum install --setopt=obsoletes=0 docker-ce-18.06.3.ce-3.el7 -y
# 4、添加一个配置文件。
# Docker 在默认情况下使用 Vgroup Driver 为 cgroupfs，而 Kubernetes 推荐使用 systemd 来替代 cgroupfs。
[root@master ~]# mkdir /etc/docker
[root@master ~]# cat < /etc/docker/daemon.json
{
	"exec-opts": ["native.cgroupdriver=systemd"],
	"registry-mirrors": ["https://4utvh5ib.mirror.aliyuncs.com"]
}
EOF
# 启动 dokcer。
[root@master ~]# systemctl restart docker
[root@master ~]# systemctl enable docker
[root@localhost ~]# sudo systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "registry-mirrors": ["https://4utvh5ib.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
sudo systemctl enable docker
[root@localhost ~]# sudo systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.

sudo yum install --setopt=obsoletes=0 docker-ce-18.06.3.ce-3.el7 docker-ce-cli containerd.io docker-compose-plugin

2.6.10 安装 Kubernetes 组件。

https://developer.aliyun.com/mirror/kubernetes

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
setenforce 0
# yum install -y kubelet kubeadm kubectl
# systemctl enable kubelet && systemctl start kubelet

# 由于 kubernetes 的镜像在国外，速度比较慢，这里切换成国内的镜像源。
# 编辑/etc/yum.repos.d/kubernetes.repo，添加下面的配置。
[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgchech=0
repo_gpgcheck=0
gpgkey=http://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
http://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
# 安装 kubeadm、kubelet 和 kubectl。
[root@master ~]# yum install --setopt=obsoletes=0 kubeadm-1.17.4-0 kubelet-1.17.4-0 kubectl-1.17.4-0 -y

# 配置 kubelet 的 cgroup。
vim /etc/sysconfig/kubelet
# 编辑 /etc/sysconfig/kubelet, 添加下面的配置。
KUBELET_CGROUP_ARGS="--cgroup-driver=systemd"
KUBE_PROXY_MODE="ipvs"
# 5、设置 kubelet 开机自启。
[root@master ~]# systemctl enable kubelet

2.6.11 准备集群镜像。

# 在安装 kubernetes 集群之前，必须要提前准备好集群需要的镜像，所需镜像可以通过下面命令查看。
[root@localhost ~]# kubeadm config images list
W1201 23:46:05.541002   55376 version.go:101] could not fetch a Kubernetes version from the internet: unable to get URL "https://dl.k8s.io/release/stable-1.txt": Get https://storage.googleapis.com/kubernetes-release/release/stable-1.txt: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)
W1201 23:46:05.541156   55376 version.go:102] falling back to the local client version: v1.17.4
W1201 23:46:05.541308   55376 validation.go:28] Cannot validate kube-proxy config - no validator is available
W1201 23:46:05.541316   55376 validation.go:28] Cannot validate kubelet config - no validator is available
k8s.gcr.io/kube-apiserver:v1.17.4
k8s.gcr.io/kube-controller-manager:v1.17.4
k8s.gcr.io/kube-scheduler:v1.17.4
k8s.gcr.io/kube-proxy:v1.17.4
k8s.gcr.io/pause:3.1
k8s.gcr.io/etcd:3.4.3-0
k8s.gcr.io/coredns:1.6.5
[root@localhost ~]# 

# 下载镜像。
# 此镜像 kubernetes 的仓库中，由于网络原因，无法连接，下面提供了一种替换方案。
images=(
	kube-apiserver:v1.17.4
	kube-controller-manager:v1.17.4
	kube-scheduler:v1.17.4
	kube-proxy:v1.17.4
	pause:3.1
	etcd:3.4.3-0
	coredns:1.6.5
)

for imageName in ${images[@]};do
	docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName
	docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName k8s.gcr.io/$imageName
	docker rmi registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName 
done

[root@localhost ~]# docker images
REPOSITORY                           TAG                 IMAGE ID            CREATED             SIZE
k8s.gcr.io/kube-proxy                v1.17.4             6dec7cfde1e5        2 years ago         116MB
k8s.gcr.io/kube-apiserver            v1.17.4             2e1ba57fe95a        2 years ago         171MB
k8s.gcr.io/kube-controller-manager   v1.17.4             7f997fcf3e94        2 years ago         161MB
k8s.gcr.io/kube-scheduler            v1.17.4             5db16c1c7aff        2 years ago         94.4MB
k8s.gcr.io/coredns                   1.6.5               70f311871ae1        3 years ago         41.6MB
k8s.gcr.io/etcd                      3.4.3-0             303ce5db0e90        3 years ago         288MB
k8s.gcr.io/pause                     3.1                 da86e6ba6ca1        4 years ago         742kB

2.6.12 集群初始化。

下面的操作只需要在 master 节点上执行即可。

https://kubernetes.io/zh-cn/docs/reference/setup-tools/kubeadm/kubeadm-init/

# 创建集群。
[root@master ~]# kubeadm init \
	--apiserver-advertise-address=192.168.142.150 \
	--image-repository=registry.aliyuncs.com/google_containers \
	--kubernetes-version=v1.17.4 \
	--pod-network-cidr=10.244.0.0/16 \
	--service-cidr=10.96.0.0/12
# To start using your cluster, you need to run the following as a regular user:
[root@master ~]# mkdir -p $HOME/.kube
[root@master ~]# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
[root@master ~]# sudo chown $(id -u):$(id -g) $HOME/.kube/config

[root@localhost ~]# kubeadm init \
> --apiserver-advertise-address=192.168.142.150 \
> --image-repository=registry.aliyuncs.com/google_containers \
> --kubernetes-version=v1.17.4 \
> --pod-network-cidr=10.244.0.0/16 \
> --service-cidr=10.96.0.0/12
W1202 00:11:31.437970   57290 validation.go:28] Cannot validate kubelet config - no validator is available
W1202 00:11:31.438028   57290 validation.go:28] Cannot validate kube-proxy config - no validator is available
[init] Using Kubernetes version: v1.17.4
[preflight] Running pre-flight checks
[preflight] Pulling images required for setting up a Kubernetes cluster
[preflight] This might take a minute or two, depending on the speed of your internet connection
[preflight] You can also perform this action in beforehand using 'kubeadm config images pull'

[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Starting the kubelet
[certs] Using certificateDir folder "/etc/kubernetes/pki"
[certs] Generating "ca" certificate and key
[certs] Generating "apiserver" certificate and key
[certs] apiserver serving cert is signed for DNS names [localhost.localdomain.k8s.master kubernetes kubernetes.default kubernetes.default.svc kubernetes.default.svc.cluster.local] and IPs [10.96.0.1 192.168.142.150]
[certs] Generating "apiserver-kubelet-client" certificate and key
[certs] Generating "front-proxy-ca" certificate and key
[certs] Generating "front-proxy-client" certificate and key
[certs] Generating "etcd/ca" certificate and key
[certs] Generating "etcd/server" certificate and key
[certs] etcd/server serving cert is signed for DNS names [localhost.localdomain.k8s.master localhost] and IPs [192.168.142.150 127.0.0.1 ::1]
[certs] Generating "etcd/peer" certificate and key
[certs] etcd/peer serving cert is signed for DNS names [localhost.localdomain.k8s.master localhost] and IPs [192.168.142.150 127.0.0.1 ::1]
[certs] Generating "etcd/healthcheck-client" certificate and key
[certs] Generating "apiserver-etcd-client" certificate and key
[certs] Generating "sa" key and public key
[kubeconfig] Using kubeconfig folder "/etc/kubernetes"
[kubeconfig] Writing "admin.conf" kubeconfig file
[kubeconfig] Writing "kubelet.conf" kubeconfig file
[kubeconfig] Writing "controller-manager.conf" kubeconfig file
[kubeconfig] Writing "scheduler.conf" kubeconfig file
[control-plane] Using manifest folder "/etc/kubernetes/manifests"
[control-plane] Creating static Pod manifest for "kube-apiserver"
[control-plane] Creating static Pod manifest for "kube-controller-manager"
W1202 00:19:51.720839   57290 manifests.go:214] the default kube-apiserver authorization-mode is "Node,RBAC"; using "Node,RBAC"
[control-plane] Creating static Pod manifest for "kube-scheduler"
W1202 00:19:51.721669   57290 manifests.go:214] the default kube-apiserver authorization-mode is "Node,RBAC"; using "Node,RBAC"
[etcd] Creating static Pod manifest for local etcd in "/etc/kubernetes/manifests"
[wait-control-plane] Waiting for the kubelet to boot up the control plane as static Pods from directory "/etc/kubernetes/manifests". This can take up to 4m0s
[apiclient] All control plane components are healthy after 23.003244 seconds
[upload-config] Storing the configuration used in ConfigMap "kubeadm-config" in the "kube-system" Namespace
[kubelet] Creating a ConfigMap "kubelet-config-1.17" in namespace kube-system with the configuration for the kubelets in the cluster
[upload-certs] Skipping phase. Please see --upload-certs
[mark-control-plane] Marking the node localhost.localdomain.k8s.master as control-plane by adding the label "node-role.kubernetes.io/master=''"
[mark-control-plane] Marking the node localhost.localdomain.k8s.master as control-plane by adding the taints [node-role.kubernetes.io/master:NoSchedule]
[bootstrap-token] Using token: xs70mz.1j3eaj8unj3g11cp
[bootstrap-token] Configuring bootstrap tokens, cluster-info ConfigMap, RBAC Roles
[bootstrap-token] configured RBAC rules to allow Node Bootstrap tokens to post CSRs in order for nodes to get long term certificate credentials
[bootstrap-token] configured RBAC rules to allow the csrapprover controller automatically approve CSRs from a Node Bootstrap Token
[bootstrap-token] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
[bootstrap-token] Creating the "cluster-info" ConfigMap in the "kube-public" namespace
[kubelet-finalize] Updating "/etc/kubernetes/kubelet.conf" to point to a rotatable kubelet client certificate and key
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

Then you can join any number of worker nodes by running the following on each as root:

kubeadm join 192.168.142.150:6443 --token xs70mz.1j3eaj8unj3g11cp \
    --discovery-token-ca-cert-hash sha256:8cb8adbc0147bc1c15fc689f98ab49e8442d16d28e85062d2db9b8f47225c6cc 
[root@localhost ~]#

[root@localhost ~]# kubectl get nodes
NAME                               STATUS     ROLES    AGE     VERSION
localhost.localdomain.k8s.master   NotReady   master   4m11s   v1.17.4

下面的操作只需要在 node 节点上执行即可。

[root@localhost ~]# kubeadm join 192.168.142.150:6443 --token xs70mz.1j3eaj8unj3g11cp \
>     --discovery-token-ca-cert-hash sha256:8cb8adbc0147bc1c15fc689f98ab49e8442d16d28e85062d2db9b8f47225c6cc 
W1202 00:25:46.290777   86902 join.go:346] [preflight] WARNING: JoinControlPane.controlPlane settings will be ignored when control-plane flag is not set.
[preflight] Running pre-flight checks
[preflight] Reading configuration from the cluster...
[preflight] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -oyaml'
[kubelet-start] Downloading configuration for the kubelet from the "kubelet-config-1.17" ConfigMap in the kube-system namespace
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Starting the kubelet
[kubelet-start] Waiting for the kubelet to perform the TLS Bootstrap...

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the control-plane to see this node join the cluster.

在 master 上查看节点信息。

[root@localhost ~]# kubectl get nodes
NAME                               STATUS     ROLES    AGE     VERSION
localhost.localdomain.k8s.master   NotReady   master   6m31s   v1.17.4
localhost.localdomain.k8s.node1    NotReady   <none>   56s     v1.17.4
localhost.localdomain.k8s.node2    NotReady   <none>   52s     v1.17.4

NotReady

↓ ↓ ↓

2.6.13 安装网络插件，只在 master 节点操作即可。

kubernetes 支持多种网络插件。eg. flannel、calico、canal 等。任选一种使用即可。本次选择 flannel。

下面操作依旧只在 master 节点执行即可，插件使用的是 DaemonSet 的控制器，ta 会在每个节点上都运行。

获取 fannel 的配置文件。

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

《k8s ~ kube-flannel.yml。》

由于外网不好访问，如果出现无法访问的情况，可以直接用下面的记得文件名是 kube-flannel.yml，位置：/root/kube-flannel.yml 内容。

https://github.com/flannel-io/flannel/tree/master/Documentation/kube-flannel.yml

《k8s ~ kube-flannel.yml。》

修改文件中的 quay.io 仓库为 quay-mirror.qiniu.com。

使用配置文件启动 fannel。

kubectl apply -f kube-flannel.yml

稍等片刻。

[root@localhost k8s]# kubectl apply -f kube-flannel.yml 
namespace/kube-flannel created
clusterrole.rbac.authorization.k8s.io/flannel created
clusterrolebinding.rbac.authorization.k8s.io/flannel created
serviceaccount/flannel created
configmap/kube-flannel-cfg created
daemonset.apps/kube-flannel-ds created

[root@localhost k8s]# kubectl get nodes
NAME                               STATUS   ROLES    AGE   VERSION
localhost.localdomain.k8s.master   Ready    master   62m   v1.17.4
localhost.localdomain.k8s.node1    Ready    <none>   57m   v1.17.4
localhost.localdomain.k8s.node2    Ready    <none>   57m   v1.17.4

也可手动拉取指定版本。

# 拉取 flannel 网络，三台主机。
docker pull quay.io/coreos/flannel:v0.14.0
# 查看仓库是否拉去下来。
docker images

若是集群状态一直是 notready，用下面语句查看原因。

journalctl -f -u kubelet.service

若原因是： cni.go:237] Unable to update cni config: no networks found in /etc/cni/net.d

mkdir -p /etc/cni/net.d
vim /etc/cni/net.d/10-flannel.conf


{
 "name":"cbr0",
 "cniVersion":"0.3.1",
 "type":"flannel",
 "deledate":{
    "hairpinMode":true,
    "isDefaultGateway":true
  }

}

2.6.14 使用 kubeadm reset 重置集群。

# 在 master 节点之外的节点进行操作。
kubeadm reset
systemctl stop kubelet
systemctl stop docker
rm -rf /var/lib/cni/
rm -rf /var/lib/kubelet/*
rm -rf /etc/cni/
ifconfig cni0 down
ifconfig flannel.1 down
ifconfig docker0 down
ip link delete cni0
ip link delete flannel.1
# 重启 kubelet。
systemctl restart kubelet
# 重启 docker。
systemctl restart docker

2.6.15 重启 kubelet 和 docker。

# 重启 kubelet
systemctl restart kubelet
# 重启 docker
systemctl restart docker

使用配置文件启动 fannel。

kubectl apply -f kube-flannel.yml

等待它安装完毕，发现集群的状态已经是 Ready。

2.6.16 kubeadm 中的命令。

# 生成新的 token。
[root@master ~]# kubeadm token create --print-join-command

2.7 集群测试。

2.7.1 创建一个 nginx 服务。

[root@localhost k8s]# kubectl create deployment nginx --image=nginx:1.14-alpine
deployment.apps/nginx created

2.7.2 暴露端口。

[root@localhost k8s]# kubectl expose deploy nginx --port=80 --target-port=80 --type=NodePort
service/nginx exposed

2.7.3 查看服务。

2.7.4 查看 pod。

[root@localhost k8s]# kubectl get pod
NAME                     READY   STATUS              RESTARTS   AGE
nginx-6867cdf567-5p8k4   0/1     ContainerCreating   0          83s


[root@localhost k8s]# kubectl get pod
NAME                     READY   STATUS    RESTARTS   AGE
nginx-6867cdf567-5p8k4   1/1     Running   0          2m47s

[root@localhost k8s]# kubectl get svc
NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1      <none>        443/TCP        71m
nginx        NodePort    10.107.6.137   <none>        80:31567/TCP   67s

3. 资源管理。

3.1 资源管理介绍。

在 kubernetes 中，所有的内容都抽象为资源，用户需要通过操作资源来管理 kubernetes。

kubernetes 的本质上就是一个集群系统，用户可以在集群中部署各种服务，所谓的部署服务，其实就是在 kubernetes 集群中运行一个个的容器，并将指定的程序跑在容器中。
kubernetes 的最小管理单元是 pod 而不是容器，所以只能将容器放在Pod中，而 kubernetes 一般也不会直接管理 Pod，而是通过Pod 控制器来管理 Pod 的。
Pod 可以提供服务之后，就要考虑如何访问 Pod 中服务，kubernetes 提供了 Service 资源实现这个功能。
当然，如果 Pod 中程序的数据需要持久化，kubernetes 还提供了各种存储系统。

学习 kubernetes 的核心，就是学习如何对集群上的Pod、Pod 控制器、Service、存储等各种资源进行操作。

3.2 YAML 语言介绍。

YAML 是一个类似 XML、JSON 的标记性语言。它强调以数据为中心，并不是以标识语言为重点。因而 YAML 本身的定义比较简单，号称"一种人性化的数据格式语言"。

<geek>
    <age>15age>
    <address>Beijingaddress>
geek>

geek:
  age: 15
  address: Beijing

YAML 的语法比较简单，主要有下面几个：

大小写敏感。
使用缩进表示层级关系。
缩进不允许使用 tab，只允许空格（低版本限制）。
缩进的空格数不重要，只要相同层级的元素左对齐即可。
# 表示注释。

YAML 支持以下几种数据类型：

纯量：单个的、不可再分的值。
对象：键值对的集合，又称为映射（mapping）/哈希（hash）/字典（dictionary）。
数组：一组按次序排列的值，又称为序列（sequence）/列表（list）。

# 纯量, 就是指的一个简单的值，字符串、布尔值、整数、浮点数、Null、时间、日期。
# 布尔类型。
eg. true (或者 True)
# 整型。
eg. 234
# 浮点型。
eg. 3.14
# null 类型。 
eg. ~  # 使用 ~ 表示 null。
# 日期类型。
eg. 2018-02-17  # 日期必须使用 ISO 8601 格式，即 yyyy-MM-dd。
# 时间类型。
eg. 2018-02-17T15:02:31+08:00  # 时间使用 ISO 8601 格式，时间和日期之间使用 T 连接，最后使用 + 代表时区。
# 字符串类型。
eg. geek  # 简单写法，直接写值，如果字符串中间有特殊字符，必须使用双引号或者单引号包裹。 
eg. line1
    line2  # 字符串过多的情况可以拆成多行，每一行会被转化成一个空格。

# 对象。
# 形式一（推荐）。
geek:
  age: 15
  address: Beijing
# 形式二（了解）。
geek: {age: 15, address: Beijing}

# 数组。
# 形式一（推荐）。
address:
  - 顺义
  - 昌平  
# 形式二（了解）。
address: [顺义, 昌平]

tips

书写 yaml 切记: 后面要加一个空格。

如果需要将多段 yaml 配置放在一个文件中，中间要使用 --- 分隔。

下面是一个 yaml 转 json 的网站，可以通过它验证 yaml 是否书写正确。
https://www.json2yaml.com/convert-yaml-to-json。

3.3 资源管理方式。

命令式对象管理：直接使用命令去操作 kubernetes 资源。

kubectl run nginx-pod --image=nginx:1.17.1 --port=80

命令式对象配置：通过命令配置和配置文件去操作 kubernetes 资源。

kubectl create/patch -f nginx-pod.yaml

声明式对象配置：通过 apply 命令和配置文件去操作 kubernetes 资源。

kubectl apply -f nginx-pod.yaml
# 创建 or 更新。

类型	操作对象	适用环境	优点	缺点
命令式对象管理	对象	测试	简单	只能操作活动对象，无法审计、跟踪
命令式对象配置	文件	开发	可以审计、跟踪	项目大时，配置文件多，操作麻烦
声明式对象配置	目录	开发	支持目录操作	意外情况下难以调试

3.3.1 命令式对象管理。

kubectl 命令。

kubectl 是 kubernetes 集群的命令行工具，通过它能够对集群本身进行管理，并能够在集群上进行容器化应用的安装部署。

kubectl 命令的语法。

kubectl [command] [type] [name] [flags]

command：指定要对资源执行的操作，例如 create、get、delete。

type：指定资源类型，比如 deployment、pod、service。

name：指定资源的名称，名称大小写敏感。

flags：指定额外的可选参数。

# 查看所有 pod。
kubectl get pod
# 查看某个 pod。
kubectl get pod pod_name
# 查看某个 pod,以 yaml / json 格式展示结果。
kubectl get pod pod_name -o yaml

[root@localhost ~]# kubectl version
Client Version: version.Info{Major:"1", Minor:"17", GitVersion:"v1.17.4", GitCommit:"8d8aa39598534325ad77120c120a22b3a990b5ea", GitTreeState:"clean", BuildDate:"2020-03-12T21:03:42Z", GoVersion:"go1.13.8", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"17", GitVersion:"v1.17.4", GitCommit:"8d8aa39598534325ad77120c120a22b3a990b5ea", GitTreeState:"clean", BuildDate:"2020-03-12T20:55:23Z", GoVersion:"go1.13.8", Compiler:"gc", Platform:"linux/amd64"}

[root@localhost ~]# kubectl cluster-info
Kubernetes master is running at https://192.168.142.150:6443
KubeDNS is running at https://192.168.142.150:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

资源类型。

kubernetes 中所有的内容都抽象为资源，可以通过下面的命令进行查看。

kubectl api-resources

经常使用的资源有下面这些。

资源分类	资源名称	缩写	资源作用
集群级别资源	nodes	no	集群组成部分
	namespaces	ns	隔离 Pod
pod 资源	pods	po	装载容器
pod 资源控制器	replicationcontrollers	rc	控制 pod 资源
	replicasets	rs	控制 pod 资源
	deployments	deploy	控制 pod 资源
	daemonsets	ds	控制 pod 资源
	jobs		控制 pod 资源
	cronjobs	cj	控制 pod 资源
	horizontalpodautoscalers	hpa	控制 pod 资源
	statefulsets	sts	控制 pod 资源
服务发现资源	services	svc	统一 pod 对外接口
	ingress	ing	统一 pod 对外接口
存储资源	volumeattachments		存储
	persistentvolumes	pv	存储
	persistentvolumeclaims	pvc	存储
配置资源	configmaps	cm	配置
	secrets		配置

操作。

kubernetes 允许对资源进行多种操作，可以通过–help 查看详细的操作命令。

kubectl --help

经常使用的操作有下面这些。

命令分类	命令	翻译	命令作用
基本命令	create	创建	创建一个资源
	edit	编辑	编辑一个资源
	get	获取	获取一个资源
	patch	更新	更新一个资源
	delete	删除	删除一个资源
	explain	解释	展示资源文档
运行和调试	run	运行	在集群中运行一个指定的镜像
	expose	暴露	暴露资源为 Service
	describe	描述	显示资源内部信息
	logs	日志输出容器在 pod 中的日志	输出容器在 pod 中的日志
	attach	缠绕进入运行中的容器	进入运行中的容器
	exec	执行容器中的一个命令	执行容器中的一个命令
	cp	复制	在 Pod 内外复制文件
	rollout	首次展示	管理资源的发布
	scale	规模	扩(缩)容 Pod 的数量
	autoscale	自动调整	自动调整 Pod 的数量
高级命令	apply	rc	通过文件对资源进行配置
	label	标签	更新资源上的标签
其他命令	cluster-info	集群信息	显示集群
	version	版本	显示当前 Server 和 Client 的版本

下面以一个 namespace / pod 的创建和删除简单演示下命令的使用。

# 创建一个 namespace。
[root@localhost ~]# kubectl create namespace dev
namespace/dev created

# 获取 namespace。
[root@localhost ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   13h
dev               Active   17s
kube-flannel      Active   12h
kube-node-lease   Active   13h
kube-public       Active   13h
kube-system       Active   13h

# 在此 namespace 下创建并运行一个 nginx 的 Pod。
[root@localhost ~]# kubectl run pod --image=nginx:1.17.1 -n dev
kubectl run --generator=deployment/apps.v1 is DEPRECATED and will be removed in a future version. Use kubectl run --generator=run-pod/v1 or kubectl create instead.
deployment.apps/pod created

# 查看新创建的 pod。不加 -n dev 默认查 default。
[root@localhost ~]# kubectl get pod -n dev
NAME                   READY   STATUS    RESTARTS   AGE
pod-644584df94-5gx6f   1/1     Running   0          3m33s
[root@localhost ~]# kubectl get pod
NAME                     READY   STATUS    RESTARTS   AGE
nginx-6867cdf567-tlmw5   1/1     Running   0          25m
[root@localhost ~]# kubectl get pod -n default
NAME                     READY   STATUS    RESTARTS   AGE
nginx-6867cdf567-tlmw5   1/1     Running   0          26m

# 删除指定的 pod。
[root@localhost ~]# kubectl delete pods pod-644584df94-5gx6f -n dev
pod "pod-644584df94-5gx6f" deleted
[root@localhost ~]# kubectl get pod -n dev
NAME                   READY   STATUS              RESTARTS   AGE
pod-644584df94-wzzcv   0/1     ContainerCreating   0          40s

# 删除后又生成了一个。控制器，后面讲解。

# 删除指定的 namespace。
[root@localhost ~]# kubectl delete ns dev
namespace "dev" deleted
[root@localhost ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   13h
kube-flannel      Active   12h
kube-node-lease   Active   13h
kube-public       Active   13h
kube-system       Active   13h
[root@localhost ~]# kubectl get pod -n dev
No resources found in dev namespace.

[root@localhost ~]# kubectl get pod -n dev

[root@localhost ~]# kubectl describe pods pod-644584df94-5gx6f -n dev
Name:         pod-644584df94-5gx6f
Namespace:    dev
Priority:     0
Node:         localhost.localdomain.k8s.node2/192.168.142.152
Start Time:   Fri, 02 Dec 2022 13:35:27 +0800
Labels:       pod-template-hash=644584df94
              run=pod
Annotations:  <none>
Status:       Running
IP:           10.244.2.3
IPs:
  IP:           10.244.2.3
Controlled By:  ReplicaSet/pod-644584df94
Containers:
  pod:
    Container ID:   docker://26a71073d6b9f116bd7411aacdf862f77c1d1f485844e33a55aa2590edeb8614
    Image:          nginx:1.17.1
    Image ID:       docker-pullable://nginx@sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
    Port:           <none>
    Host Port:      <none>
    State:          Running
      Started:      Fri, 02 Dec 2022 13:36:34 +0800
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-khzf8 (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-khzf8:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-khzf8
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute for 300s
                 node.kubernetes.io/unreachable:NoExecute for 300s
Events:
  Type    Reason     Age    From                                      Message
  ----    ------     ----   ----                                      -------
  Normal  Scheduled  5m24s  default-scheduler                         Successfully assigned dev/pod-644584df94-5gx6f to localhost.localdomain.k8s.node2
  Normal  Pulling    5m23s  kubelet, localhost.localdomain.k8s.node2  Pulling image "nginx:1.17.1"
  Normal  Pulled     4m19s  kubelet, localhost.localdomain.k8s.node2  Successfully pulled image "nginx:1.17.1"
  Normal  Created    4m18s  kubelet, localhost.localdomain.k8s.node2  Created container pod
  Normal  Started    4m17s  kubelet, localhost.localdomain.k8s.node2  Started container pod

3.3.2 命令式对象配置。

命令式对象配置就是使用命令配合配置文件一起来操作 kubernetes 资源。

1）创建一个 nginxpod.yaml，内容如下。

apiVersion: v1
kind: Namespace
metadata:
  name: dev

---

apiVersion: v1
kind: Pod
metadata:
  name: nginxpod
  namespace: dev
spec:
  containers:
  - name: nginx-containers
    image: nginx:1.17.1

2）执行 create 命令，创建资源。

[root@localhost k8s]# kubectl create -f nginxpod.yaml 
namespace/dev created
pod/nginxpod created

此时发现创建了两个资源对象，分别是 namespace 和 pod。

[root@localhost k8s]# kubectl get ns dev
NAME   STATUS   AGE
dev    Active   37s
[root@localhost k8s]# kubectl get pod -n dev
NAME       READY   STATUS              RESTARTS   AGE
nginxpod   0/1     ContainerCreating   0          43s
[root@localhost k8s]# kubectl get pods -n dev
NAME       READY   STATUS    RESTARTS   AGE
nginxpod   1/1     Running   0          90s

3）执行 get 命令，查看资源。

[root@localhost k8s]# kubectl get -f nginxpod.yaml
NAME            STATUS   AGE
namespace/dev   Active   2m15s

NAME           READY   STATUS    RESTARTS   AGE
pod/nginxpod   1/1     Running   0          2m14s

这样就显示了两个资源对象的信息。

4）执行 delete 命令，删除资源：

[root@localhost k8s]# kubectl delete -f nginxpod.yaml
namespace "dev" deleted
pod "nginxpod" deleted

此时发现两个资源对象被删除了。

总结。

命令式对象配置的方式操作资源，可以简单的认为：命令 + yaml 配置文件（里面是命令需要的各种参数）。

3.3.3 声明式对象配置。

声明式对象配置跟命令式对象配置很相似，但是它只有一个命令 apply。

# 首先执行一次 kubectl apply -f yaml 文件，发现创建了资源。
[root@localhost k8s]# kubectl apply -f nginxpod.yaml
namespace/dev created
pod/nginxpod created
# 再次执行一次 kubectl apply -f yaml 文件，发现说资源没有变动。
[root@localhost k8s]# kubectl apply -f nginxpod.yaml
namespace/dev unchanged
pod/nginxpod unchanged

[root@localhost k8s]# kubectl apply -f nginxpod.yaml
namespace/dev unchanged
pod/nginxpod unchanged
[root@localhost k8s]# !vim
vim nginxpod.yaml
[root@localhost k8s]# kubectl apply -f nginxpod.yaml
namespace/dev unchanged
pod/nginxpod configured
[root@localhost k8s]# kubectl describe pods nginxpod -n dev
Name:         nginxpod
Namespace:    dev
Priority:     0
Node:         localhost.localdomain.k8s.node2/192.168.142.152
Start Time:   Fri, 02 Dec 2022 13:52:33 +0800
Labels:       <none>
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"v1","kind":"Pod","metadata":{"annotations":{},"name":"nginxpod","namespace":"dev"},"spec":{"containers":[{"image":"nginx:1....
Status:       Running
IP:           10.244.2.6
IPs:
  IP:  10.244.2.6
Containers:
  nginx-containers:
    Container ID:   docker://37a117c2d9d75053ce590c9d1fc306d5c90053960258891fff5bf0c046840089
    Image:          nginx:1.17.1
    Image ID:       docker-pullable://nginx@sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
    Port:           
    Host Port:      
    State:          Running
      Started:      Fri, 02 Dec 2022 13:53:30 +0800
    Ready:          True
    Restart Count:  0
    Environment:    
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-5ksc8 (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-5ksc8:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-5ksc8
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  
Tolerations:     node.kubernetes.io/not-ready:NoExecute for 300s
                 node.kubernetes.io/unreachable:NoExecute for 300s
Events:
  Type    Reason     Age    From                                      Message
  ----    ------     ----   ----                                      -------
  Normal  Scheduled  3m     default-scheduler                         Successfully assigned dev/nginxpod to localhost.localdomain.k8s.node2
  Normal  Pulling    2m59s  kubelet, localhost.localdomain.k8s.node2  Pulling image "nginx:1.17.1"
  Normal  Pulled     2m3s   kubelet, localhost.localdomain.k8s.node2  Successfully pulled image "nginx:1.17.1"
  Normal  Created    2m3s   kubelet, localhost.localdomain.k8s.node2  Created container nginx-containers
  Normal  Started    2m3s   kubelet, localhost.localdomain.k8s.node2  Started container nginx-containers
  Normal  Killing    52s    kubelet, localhost.localdomain.k8s.node2  Container nginx-containers definition changed, will be restarted
  Normal  Pulling    52s    kubelet, localhost.localdomain.k8s.node2  Pulling image "nginx:1.17.1"


[root@localhost k8s]# kubectl create -f nginxpod.yaml
Error from server (AlreadyExists): error when creating "nginxpod.yaml": namespaces "dev" already exists
Error from server (AlreadyExists): error when creating "nginxpod.yaml": pods "nginxpod" already exists

总结。

其实声明式对象配置就是使用 apply 描述一个资源最终的状态（在 yaml 中定义状态）。

使用 apply 操作资源。

如果资源不存在，就创建，相当于 kubectl create。
如果资源已存在，就更新，相当于 kubectl patch。

扩展：kubectl 可以在 node 节点上运行吗？

[root@localhost ~]# kubectl get nodes
The connection to the server localhost:8080 was refused - did you specify the right host or port?

kubectl 的运行是需要进行配置的，它的配置文件是 $HOME/.kube，如果想要在 node 节点运行此命令，需要将 master 上的 .kube 文件复制到 node 节点上，即在 master 节点上执行下面操作：

scp -r $HOME/.kube localhost.localdomain.k8s.node1:$HOME/

[root@localhost ~]# ls .kube/
cache  config  http-cache

使用推荐: 三种方式应该怎么用？

创建/更新资源使用声明式对象配置 kubectl apply -f XXX.yaml。

删除资源使用命令式对象配置 kubectl delete -f XXX.yaml。

查询资源使用命令式对象管理 kubectl get(describe) 资源名称。

4. 实战入门。

本章节将介绍如何在 kubernetes 集群中部署一个 Nginx 服务，并且能够对其进行访问。

4.1 Namespace。

Namespace 是 kubernetes 系统中的一种非常重要资源，它的主要作用是用来实现多套环境的资源隔离或者多租户的资源隔离。

默认情况下，kubernetes 集群中的所有的 Pod 都是可以相互访问的。但是在实际中，可能不想让两个 Pod 之间进行互相的访问，那此时就可以将两个 Pod 划分到不同的 namespace 下。kubernetes 通过将集群内部的资源分配到不同的 Namespace 中，可以形成逻辑上的"组"，以方便不同的组的资源进行隔离使用和管理。

可以通过 kubernetes 的授权机制，将不同的 namespace 交给不同租户进行管理，这样就实现了多租户的资源隔离。此时还能结合 kubernetes 的资源配额机制，限定不同租户能占用的资源，例如 CPU 使用量、内存使用量等等，来实现租户可用资源的管理。

kubernetes 在集群启动之后，会默认创建几个 namespace。

[root@localhost ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   13h  # 所有未指定 Namespace 的对象都会被分配在 default 命名空间。
#dev               Active   17m
#kube-flannel      Active   12h
kube-node-lease   Active   13h  # 集群节点之间的心跳维护，v1.13 开始引入。
kube-public       Active   13h  # 此命名空间下的资源可以被所有人访问（包括未认证用户）。
kube-system       Active   13h  # 所有由 Kubernetes 系统创建的资源都处于这个命名空间。

下面来看 namespace 资源的具体操作。

4.1.1 查看。

# 查看所有的 ns。命令：kubectl get ns
[root@localhost ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   13h
dev               Active   23m
kube-flannel      Active   12h
kube-node-lease   Active   13h
kube-public       Active   13h
kube-system       Active   13h

[root@localhost ~]# kubectl get pods -n kube-system
NAME                                                       READY   STATUS    RESTARTS   AGE
coredns-9d85f5447-5959v                                    1/1     Running   0          13h
coredns-9d85f5447-gvqxh                                    1/1     Running   0          13h
etcd-localhost.localdomain.k8s.master                      1/1     Running   0          13h
kube-apiserver-localhost.localdomain.k8s.master            1/1     Running   0          13h
kube-controller-manager-localhost.localdomain.k8s.master   1/1     Running   0          13h
kube-proxy-7dc95                                           1/1     Running   1          13h
kube-proxy-7hss2                                           1/1     Running   0          13h
kube-proxy-rpnvx                                           1/1     Running   0          13h
kube-scheduler-localhost.localdomain.k8s.master            1/1     Running   0          13h


# 查看指定的 ns。命令：kubectl get ns ns 名称
[root@localhost ~]# kubectl get ns default
NAME      STATUS   AGE
default   Active   13h

# 指定输出格式。命令：kubectl get ns ns 名称 -o 格式参数
# kubernetes 支持的格式有很多，比较常见的是 wide、json、yaml
[root@localhost ~]# kubectl get ns default -o yaml
apiVersion: v1
kind: Namespace
metadata:
  creationTimestamp: "2022-12-01T16:20:14Z"
  name: default
  resourceVersion: "146"
  selfLink: /api/v1/namespaces/default
  uid: 11fb6c7d-f67f-4d9e-8e2b-66621c0d5d08
spec:
  finalizers:
  - kubernetes
status:
  phase: Active

# 查看 ns 详情。命令：kubectl describe ns ns 名称
[root@localhost ~]# kubectl describe ns default
Name:         default
Labels:       <none>
Annotations:  <none>
Status:       Active

No resource quota.

No LimitRange resource.

# status
# Active 命名空间正在使用中 Terminating 正在删除命名空间。
# ResourceQuota 针对 namespace 做的资源限制。
# LimitRange 针对 namespace 中的每个组件做的资源限制。

4.1.2 创建。

# 创建 namespace。
[root@master ~]# kubectl create ns dev
namespace/dev created

4.1.3 删除。

# 删除 namespace。
[root@master ~]# kubectl delete ns dev
namespace "dev" deleted

4.1.4 配置方式。

首先准备一个 yaml 文件：ns-dev.yaml。

apiVersion: v1
kind: Namespace
metadata:
  name: dev

然后就可以执行对应的创建和删除命令了：

创建：kubectl create -f ns-dev.yaml。

删除：kubectl delete -f ns-dev.yaml。

[root@localhost k8s]# vim ns-dev.yaml
[root@localhost k8s]# kubectl create -f ns-dev.yaml
Error from server (AlreadyExists): error when creating "ns-dev.yaml": namespaces "dev" already exists
[root@localhost k8s]# kubectl delete -f ns-dev.yaml
namespace "dev" deleted
[root@localhost k8s]# kubectl create -f ns-dev.yaml
namespace/dev created

4.2 Pod。

Pod 是 kubernetes 集群进行管理的最小单元，程序要运行必须部署在容器中，而容器必须存在于 Pod 中。

Pod 可以认为是容器的封装，一个 Pod 中可以存在一个或者多个容器。

kubernetes 在集群启动之后，集群中的各个组件也都是以 Pod 方式运行的。可以通过下面命令查看。

[root@localhost k8s]# kubectl get pod -n kube-system
NAME                                                       READY   STATUS    RESTARTS   AGE
coredns-9d85f5447-5959v                                    1/1     Running   0          14h
coredns-9d85f5447-gvqxh                                    1/1     Running   0          14h
etcd-localhost.localdomain.k8s.master                      1/1     Running   0          14h
kube-apiserver-localhost.localdomain.k8s.master            1/1     Running   0          14h
kube-controller-manager-localhost.localdomain.k8s.master   1/1     Running   0          14h
kube-proxy-7dc95                                           1/1     Running   1          14h
kube-proxy-7hss2                                           1/1     Running   0          14h
kube-proxy-rpnvx                                           1/1     Running   0          14h
kube-scheduler-localhost.localdomain.k8s.master            1/1     Running   0          14h

4.2.1 创建并运行。

kubernetes 没有提供单独运行 Pod 的命令，都是通过 Pod 控制器来实现的。

# 命令格式：kubectl run (pod 控制器名称) [参数] 
# --image  指定 Pod 的镜像。
# --port   指定端口。
# --namespace  指定 namespace。
[root@localhost k8s]# kubectl run nginx --image=nginx:1.17.1 --port=80 --namespace dev
kubectl run --generator=deployment/apps.v1 is DEPRECATED and will be removed in a future version. Use kubectl run --generator=run-pod/v1 or kubectl create instead.
deployment.apps/nginx created

[root@localhost k8s]# kubectl get pod -n dev
NAME                     READY   STATUS    RESTARTS   AGE
nginx-64777cd554-kwbhk   1/1     Running   0          2m8s
[root@localhost k8s]# kubectl get pod -n dev -o wide
NAME                     READY   STATUS    RESTARTS   AGE     IP           NODE                              NOMINATED NODE   READINESS GATES
nginx-64777cd554-kwbhk   1/1     Running   0          2m13s   10.244.2.7   localhost.localdomain.k8s.node2   <none>           <none>

# READY ~ pod 中容器数量。

4.2.2 查看 pod 信息。

# 查看 Pod 基本信息。
[root@localhost k8s]# kubectl get pods -n dev
NAME                     READY   STATUS    RESTARTS   AGE
nginx-64777cd554-kwbhk   1/1     Running   0          4m26s

# 查看 Pod 的详细信息。
[root@localhost k8s]# kubectl describe pod nginx -n dev
Name:         nginx-64777cd554-kwbhk
Namespace:    dev
Priority:     0
Node:         localhost.localdomain.k8s.node2/192.168.142.152
Start Time:   Fri, 02 Dec 2022 14:41:15 +0800
Labels:       pod-template-hash=64777cd554
              run=nginx
Annotations:  <none>
Status:       Running
IP:           10.244.2.7
IPs:
  IP:           10.244.2.7
Controlled By:  ReplicaSet/nginx-64777cd554
Containers:
  nginx:
    Container ID:   docker://f96e2bc540280474d7e6f7942ae42c08b485b86e18c090152d0bcdf6ea6fed21
    Image:          nginx:1.17.1
    Image ID:       docker-pullable://nginx@sha256:b4b9b3eee194703fc2fa8afa5b7510c77ae70cfba567af1376a573a967c03dbb
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Fri, 02 Dec 2022 14:41:17 +0800
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-z9vht (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-z9vht:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-z9vht
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute for 300s
                 node.kubernetes.io/unreachable:NoExecute for 300s
Events:
  Type    Reason     Age    From                                      Message
  ----    ------     ----   ----                                      -------
  Normal  Scheduled  4m37s  default-scheduler                         Successfully assigned dev/nginx-64777cd554-kwbhk to localhost.localdomain.k8s.node2
  Normal  Pulled     4m36s  kubelet, localhost.localdomain.k8s.node2  Container image "nginx:1.17.1" already present on machine
  Normal  Created    4m36s  kubelet, localhost.localdomain.k8s.node2  Created container nginx
  Normal  Started    4m35s  kubelet, localhost.localdomain.k8s.node2  Started container nginx

4.2.3 访问 Pod。

# 获取 pod IP。
[root@localhost k8s]# kubectl get pods -n dev -o wide
NAME                     READY   STATUS    RESTARTS   AGE     IP           NODE                              NOMINATED NODE   READINESS GATES
nginx-64777cd554-kwbhk   1/1     Running   0          8m32s   10.244.2.7   localhost.localdomain.k8s.node2   <none>           <none>

# 访问 POD。
[root@localhost k8s]# curl http://10.244.2.7:80
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
    }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

4.2.4 删除指定 Pod。

# 删除指定 Pod。
[root@localhost k8s]# kubectl get pod -n dev
NAME                     READY   STATUS    RESTARTS   AGE
nginx-64777cd554-kwbhk   1/1     Running   0          11m

# 此时，显示删除 Pod 成功，但是再查询，发现又新产生了一个。 
[root@localhost k8s]# kubectl get pod -n dev
NAME                     READY   STATUS    RESTARTS   AGE
nginx-64777cd554-xwknq   1/1     Running   0          26s

# kubectl run (pod 控制器名称) [参数] 
# 这是因为当前 Pod 是由 Pod 控制器创建的，控制器会监控 Pod 状况，一旦发现 Pod 死亡，会立即重建。
# 此时要想删除 Pod，必须删除 Pod 控制器。
# 先来查询一下当前 namespace 下的 Pod 控制器。
[root@localhost k8s]# kubectl get deploy -n dev
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
nginx   1/1     1            1           12m

# 接下来，删除此 Pod 控制器。
[root@localhost k8s]# kubectl delete deploy nginx -n dev
deployment.apps "nginx" deleted

# 稍等片刻，再查询 Pod，发现 Pod 被删除了。
[root@localhost k8s]# kubectl get pods -n dev
No resources found in dev namespace.

4.2.5 配置操作。

创建一个 pod-nginx.yaml，内容如下。

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  namespace: dev
spec:
  containers:
  - image: nginx:1.17.1
    name: pod
    ports:
    - name: nginx-port
      containerPort: 80
      protocol: TCP

然后就可以执行对应的创建和删除命令了。

[root@localhost k8s]# vim pod-nginx.yaml
[root@localhost k8s]# kubectl create -f pod-nginx.yaml
pod/nginx created
[root@localhost k8s]# kubectl delete -f pod-nginx.yaml
pod "nginx" deleted

4.3 Label。

Label 是 kubernetes 系统中的一个重要概念。它的作用就是在资源上添加标识，用来对它们进行区分和选择。

Label 的特点。

一个 Label 会以 key/value 键值对的形式附加到各种对象上，如 Node、Pod、Service 等等。
一个资源对象可以定义任意数量的 Label，同一个 Label 也可以被添加到任意数量的资源对象上去。
Label 通常在资源对象定义时确定，当然也可以在对象创建后动态添加或者删除。

可以通过 Label 实现资源的多维度分组，以便灵活、方便地进行资源分配、调度、配置、部署等管理工作。

一些常用的 Label 示例如下：

版本标签：“version”:“release”, “version”:“stable”…

环境标签：“environment”:“dev”，“environment”:“test”，“environment”:“pro”

架构标签：“tier”:“frontend”，“tier”:“backend”。

标签定义完毕之后，还要考虑到标签的选择，这就要使用到 Label Selector，即：

Label 用于给某个资源对象定义标识。
Label Selector 用于查询和筛选拥有某些标签的资源对象。

当前有两种 Label Selector。

基于等式的 Label Selector。

name = slave: 选择所有包含 Label 中 key=“name” 且 value=“slave” 的对象。
env != production: 选择所有包括 Label 中的 key=“env” 且 value 不等于 “production” 的对象。

基于集合的 Label Selector。

name in (master, slave): 选择所有包含 Label 中的 key=“name” 且 value=“master” 或 “slave” 的对象。
name not in (frontend): 选择所有包含 Label 中的 key=“name” 且 value 不等于 “frontend” 的对象。

标签的选择条件可以使用多个，此时将多个 Label Selector 进行组合，使用逗号","进行分隔即可。例如：

name=slave，env!=production
name not in (frontend)，env!=production

4.3.1 命令方式。

[root@localhost k8s]# kubectl create -f pod-nginx.yaml 
pod/nginx created
# 查看标签。
[root@localhost k8s]# kubectl get pod -n dev --show-labels
NAME    READY   STATUS    RESTARTS   AGE   LABELS
nginx   1/1     Running   0          69s   <none>
# 为 pod 资源打标签。
[root@localhost k8s]# kubectl label pod nginx version=1.0 -n dev
pod/nginx labeled
# 查看标签。
[root@localhost k8s]# kubectl get pod -n dev --show-labels
NAME    READY   STATUS    RESTARTS   AGE     LABELS
nginx   1/1     Running   0          2m19s   version=1.0
# 追加打标签。
[root@localhost k8s]# kubectl label pod nginx tier=back -n dev
pod/nginx labeled
# 查看标签。
[root@localhost k8s]# kubectl get pod -n dev --show-labels
NAME    READY   STATUS    RESTARTS   AGE    LABELS
nginx   1/1     Running   0          3m4s   tier=back,version=1.0

# 为 pod 资源更新标签。
[root@localhost k8s]# kubectl label pod nginx version=2.0 -n dev
error: 'version' already has a value (1.0), and --overwrite is false
[root@localhost k8s]# kubectl label pod nginx version=2.0 -n dev --overwrite
pod/nginx labeled
[root@localhost k8s]# kubectl get pod -n dev --show-labels
NAME    READY   STATUS    RESTARTS   AGE     LABELS

# 筛选标签。


apiVersion: v1
kind: Pod
metadata:
  name: nginx1
  namespace: dev
spec:
  containers:
  - image: nginx:1.17.1
    name: pod
    ports:
    - name: nginx-port
      containerPort: 80
      protocol: TCP

[root@localhost k8s]# vim pod-nginx1.yaml 
[root@localhost k8s]# kubectl create -f pod-nginx1.yaml 
pod/nginx1 created
[root@localhost k8s]# kubectl label pod nginx1 version=1.0 -n dev --overwrite
pod/nginx1 labeled
[root@localhost k8s]# kubectl get pods -n dev --show-labels
NAME     READY   STATUS    RESTARTS   AGE   LABELS
nginx    1/1     Running   0          10m   tier=back,version=2.0
nginx1   1/1     Running   0          48s   version=1.0

[root@localhost k8s]# kubectl get pod -n dev -l version=2.0 --show-labels
NAME    READY   STATUS    RESTARTS   AGE   LABELS
nginx   1/1     Running   0          11m   tier=back,version=2.0
[root@localhost k8s]# kubectl get pod -n dev -l version!=2.0 --show-labels
NAME     READY   STATUS    RESTARTS   AGE    LABELS
nginx1   1/1     Running   0          117s   version=1.0
[root@localhost k8s]# kubectl get pod -n dev -l version=3.0 --show-labels
No resources found in dev namespace.

# 删除标签。
[root@localhost k8s]# kubectl label pod nginx tier- -n dev
pod/nginx labeled
[root@localhost k8s]# kubectl get pods -n dev --show-labels
NAME     READY   STATUS    RESTARTS   AGE     LABELS
nginx    1/1     Running   0          14m     version=2.0
nginx1   1/1     Running   0          4m32s   version=1.0

4.3.2 配置方式。

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  namespace: dev
  labels:
    version: "3.0" 
    env: "test"
spec:
  containers:
  - image: nginx:1.17.1
    name: pod
    ports:
    - name: nginx-port
      containerPort: 80
      protocol: TCP

然后就可以执行对应的更新命令了：kubectl apply -f pod-nginx.yaml。

4.4 Deployment。

在 kubernetes 中，Pod 是最小的控制单元，但是 kubernetes 很少直接控制 Pod，一般都是通过 Pod 控制器来完成的。Pod 控制器用于 pod 的管理，确保 pod 资源符合预期的状态，当 pod 的资源出现故障时，会尝试进行重启或重建 pod。

在 kubernetes 中 Pod 控制器的种类有很多，本章节只介绍一种：Deployment。

4.4.1 命令操作。

kubectl run。。。
底层使用了 pod 控制器。

# 命令格式: kubectl create deployment 名称 [参数] 
# --image  指定 pod 的镜像。
# --port   指定端口。
# --replicas  指定创建 pod 数量。
# --namespace  指定 namespace。
[root@localhost ~]# kubectl delete ns dev
namespace "dev" deleted
[root@localhost ~]# kubectl create ns dev
namespace/dev created
[root@localhost ~]# kubectl get deployment, pods -n dev
error: arguments in resource/name form must have a single resource and name
[root@localhost ~]# kubectl get deployment,pods -n dev
No resources found in dev namespace.
[root@localhost ~]# kubectl run nginx --image=nginx:1.17.1 --port=80 --replicas=3 -n dev
kubectl run --generator=deployment/apps.v1 is DEPRECATED and will be removed in a future version. Use kubectl run --generator=run-pod/v1 or kubectl create instead.
deployment.apps/nginx created

# 查看创建的 Pod。
[root@localhost ~]# kubectl get deployment,pods -n dev
NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx   2/3     3            2           44s

NAME                         READY   STATUS              RESTARTS   AGE
pod/nginx-64777cd554-64kzc   0/1     ContainerCreating   0          44s
pod/nginx-64777cd554-6zmhj   1/1     Running             0          44s
pod/nginx-64777cd554-tdrjw   1/1     Running             0          44s
# 查看 deployment 的信息。
[root@localhost ~]# kubectl get deploy -n dev
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
nginx   3/3     3            3           4m16s

[root@localhost ~]# kubectl get pods -n dev --show-labels
NAME                     READY   STATUS    RESTARTS   AGE     LABELS
nginx-64777cd554-64kzc   1/1     Running   0          3m38s   pod-template-hash=64777cd554,run=nginx
nginx-64777cd554-6zmhj   1/1     Running   0          3m38s   pod-template-hash=64777cd554,run=nginx
nginx-64777cd554-tdrjw   1/1     Running   0          3m38s   pod-template-hash=64777cd554,run=nginx

# UP-TO-DATE：成功升级的副本数量
# AVAILABLE：可用副本的数量
[root@localhost ~]# kubectl get deploy -n dev -o wide
NAME    READY   UP-TO-DATE   AVAILABLE   AGE    CONTAINERS   IMAGES         SELECTOR
nginx   3/3     3            3           6m7s   nginx        nginx:1.17.1   run=nginx

# 查看 deployment 的详细信息。
[root@localhost ~]# kubectl describe deploy nginx -n dev
Name:                   nginx
Namespace:              dev
CreationTimestamp:      Fri, 02 Dec 2022 23:28:04 +0800
Labels:                 run=nginx
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               run=nginx
Replicas:               3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  run=nginx
  Containers:
   nginx:
    Image:        nginx:1.17.1
    Port:         80/TCP
    Host Port:    0/TCP
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  <none>
NewReplicaSet:   nginx-64777cd554 (3/3 replicas created)
Events:
  Type    Reason             Age    From                   Message
  ----    ------             ----   ----                   -------
  Normal  ScalingReplicaSet  6m33s  deployment-controller  Scaled up replica set nginx-64777cd554 to 3

# 删除。
[root@localhost ~]# kubectl delete deploy nginx -n dev
deployment.apps "nginx" deleted
[root@localhost ~]# kubectl get pods -n dev
No resources found in dev namespace.

4.4.2 配置操作。

创建一个 deploy-nginx.yaml，内容如下。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  namespace: dev
spec:
  replicas: 3
  selector:
    matchLabels:
      run: nginx
  template:
    metadata:
      labels:
        run: nginx
    spec:
      containers:
      - image: nginx:1.17.1
        name: nginx
        ports:
        - containerPort: 80
          protocol: TCP

然后就可以执行对应的创建和删除命令了：

创建：kubectl create -f deploy-nginx.yaml。

删除：kubectl delete -f deploy-nginx.yaml。

[root@localhost k8s]# vim deploy-nginx.yaml
[root@localhost k8s]# kubectl create -f deploy-nginx.yaml 
deployment.apps/nginx created
[root@localhost k8s]# kubectl get deployment,pods -n dev
NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx   3/3     3            3           33s

NAME                         READY   STATUS    RESTARTS   AGE
pod/nginx-64777cd554-25w54   1/1     Running   0          32s
pod/nginx-64777cd554-p862l   1/1     Running   0          32s
pod/nginx-64777cd554-ppsbl   1/1     Running   0          33s
[root@localhost k8s]# kubectl delete -f deploy-nginx.yaml 
deployment.apps "nginx" deleted
[root@localhost k8s]# kubectl get deployment,pods -n dev
NAME                         READY   STATUS        RESTARTS   AGE
pod/nginx-64777cd554-25w54   0/1     Terminating   0          59s
pod/nginx-64777cd554-p862l   0/1     Terminating   0          59s
pod/nginx-64777cd554-ppsbl   0/1     Terminating   0          60s
[root@localhost k8s]# kubectl get deployment,pods -n dev
No resources found in dev namespace.
[root@localhost k8s]#

4.5 Service。

通过上节课的学习，已经能够利用 Deployment 来创建一组 Pod 来提供具有高可用性的服务。

[root@localhost k8s]# kubectl create -f deploy-nginx.yaml 
deployment.apps/nginx created
[root@localhost k8s]# kubectl get pods -n dev -o wide
NAME                     READY   STATUS    RESTARTS   AGE   IP            NODE                              NOMINATED NODE   READINESS GATES
nginx-64777cd554-8d26x   1/1     Running   0          19s   10.244.1.5    localhost.localdomain.k8s.node1   <none>           <none>
nginx-64777cd554-dtm27   1/1     Running   0          19s   10.244.2.17   localhost.localdomain.k8s.node2   <none>           <none>
nginx-64777cd554-t9x4n   1/1     Running   0          19s   10.244.2.16   localhost.localdomain.k8s.node2   <none>           <none>
[root@localhost k8s]# curl 10.244.1.5
curl: (7) Failed connect to 10.244.1.5:80; Connection refused

# 删除后，会重新创建一个新 pod，ip 会变。
[root@localhost k8s]# kubectl delete pod nginx-64777cd554-t9x4n -n dev
pod "nginx-64777cd554-t9x4n" deleted
[root@localhost k8s]# kubectl get pods -n dev -o wide
NAME                     READY   STATUS    RESTARTS   AGE     IP            NODE                              NOMINATED NODE   READINESS GATES
nginx-64777cd554-8d26x   1/1     Running   0          4m50s   10.244.1.5    localhost.localdomain.k8s.node1   <none>           <none>
nginx-64777cd554-ck66j   1/1     Running   0          10s     10.244.2.18   localhost.localdomain.k8s.node2   <none>           <none>
nginx-64777cd554-dtm27   1/1     Running   0          4m50s   10.244.2.17   localhost.localdomain.k8s.node2   <none>           <none>

虽然每个 Pod 都会分配一个单独的 Pod IP，然而却存在如下两问题：

Pod IP 会随着 Pod 的重建产生变化。
Pod IP 仅仅是集群内可见的虚拟 IP，外部无法访问。

这样对于访问这个服务带来了难度。因此，kubernetes 设计了 Service 来解决这个问题。

Service 可以看作是一组同类 Pod 对外的访问接口。借助 Service，应用可以方便地实现服务发现和负载均衡。

4.5.1 创建集群内部可访问的 Service。

# 暴露 Service。
[root@localhost k8s]# kubectl expose deploy nginx --name=svc-nginx1 --type=ClusterIP --port=80 --target-port=80 -n dev
service/svc-nginx1 exposed

# 查看 service。
[root@localhost k8s]# kubectl get service -n dev
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
svc-nginx1   ClusterIP   10.104.13.248   <none>        80/TCP    17s

# 这里产生了一个 CLUSTER-IP，这就是 service 的 IP，在 Service 的生命周期中，这个地址是不会变动的。
# 可以通过这个 IP 访问当前 service 对应的 POD。
[root@master ~]# curl 10.104.13.248:80
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
</head>
<body>
<h1>Welcome to nginx!</h1>
.......
</body>
</html>

4.5.2 创建集群外部也可访问的 Service。

# 上面创建的 Service 的 type 类型为 ClusterIP，这个 ip 地址只用集群内部可访问。
# 如果需要创建外部也可以访问的 Service，需要修改 type 为 NodePort。
[root@localhost k8s]# kubectl expose deploy nginx --name=svc-nginx2 --type=NodePort --port=80 --target-port=80 -n dev
service/svc-nginx2 exposed

# 此时查看，会发现出现了 NodePort 类型的 Service，而且有一对 Port（80:31928/TC）。
[root@localhost k8s]# kubectl get svc -n dev
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
svc-nginx1   ClusterIP   10.104.13.248   <none>        80/TCP         22m
svc-nginx2   NodePort    10.97.109.91    <none>        80:30228/TCP   2m17s

# 接下来就可以通过集群外的主机访问节点 IP:30228 访问服务了。
# 例如在的电脑主机上通过浏览器访问下面的地址。
http://192.168.142.150:30228

4.5.3 删除 Service。

[root@localhost k8s]# kubectl delete service svc-nginx1 -n dev
service "svc-nginx1" deleted
[root@localhost k8s]# kubectl delete svc svc-nginx2 -n dev
service "svc-nginx2" deleted

4.5.4 配置方式。

创建一个 svc-nginx.yaml，内容如下。

apiVersion: v1
kind: Service
metadata:
  name: svc-nginx
  namespace: dev
spec:
  clusterIP: 10.109.179.231  # 固定 svc 的内网 ip。
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: nginx
  type: ClusterIP

然后就可以执行对应的创建和删除命令了：

创建：kubectl create -f svc-nginx.yaml。

删除：kubectl delete -f svc-nginx.yaml。

[root@localhost k8s]# vim svc-nginx.yaml
[root@localhost k8s]# kubectl create -f svc-nginx.yaml 
service/svc-nginx created
[root@localhost k8s]# kubectl get service -n dev
NAME        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)   AGE
svc-nginx   ClusterIP   10.109.179.231   <none>        80/TCP    13s
[root@localhost k8s]# curl 10.109.179.231:80
curl: (7) Failed connect to 10.109.179.231:80; Connection refused
[root@localhost k8s]# kubectl delete -f svc-nginx.yaml 
service "svc-nginx" deleted
[root@localhost k8s]# kubectl get service -n dev
No resources found in dev namespace.

小结。

至此，已经掌握了 Namespace、Pod、Deployment、Service 资源的基本操作，有了这些操作，就可以在 kubernetes 集群中实现一个服务的简单部署和访问了，但是如果想要更好的使用 kubernetes，就需要深入学习这几种资源的细节和原理。

5. Pod 详解。

5.1 Pod 介绍。

5.1.1 Pod 结构。

每个 Pod 中都可以包含一个或者多个容器，这些容器可以分为两类：

用户程序所在的容器，数量可多可少。
Pause 容器，这是每个 Pod 都会有的一个根容器，它的作用有两个：

可以以它为依据，评估整个 Pod 的健康状态。

可以在根容器上设置 Ip 地址，其它容器都此 Ip（Pod IP），以实现 Pod 内部的网路通信。

这里是 Pod 内部的通讯，Pod 的之间的通讯采用虚拟二层网络技术来实现，我们当前环境用的是 Flannel。

5.1.2 Pod 定义。

下面是 Pod 的资源清单。

apiVersion: v1  # 必选，版本号，例如 v1。
kind: Pod  # 必选，资源类型，例如 Pod。
metadata:  # 必选，元数据。
  name: string  # 必选，Pod 名称。
  namespace: string  # Pod 所属的命名空间，默认为 "default"。
  labels: # 自定义标签列表。
    - name: string
spec: # 必选，Pod 中容器的详细定义。
  containers: # 必选，Pod 中容器列表。
    - name: string  # 必选，容器名称。
      image: string  # 必选，容器的镜像名称。
      imagePullPolicy: [ Always|Never|IfNotPresent ]  # 获取镜像的策略。
        command: [ string ]  # 容器的启动命令列表，如不指定，使用打包时使用的启动命令。
          args: [ string ]  # 容器的启动命令参数列表。
            workingDir: string  # 容器的工作目录。
              volumeMounts: # 挂载到容器内部的存储卷配置。
                - name: string  # 引用 pod 定义的共享存储卷的名称，需用 volumes[] 部分定义的的卷名。
                  mountPath: string  # 存储卷在容器内 mount 的绝对路径，应少于 512 字符。
                  readOnly: boolean  # 是否为只读模式。
              ports: # 需要暴露的端口库号列表。
                - name: string  # 端口的名称。
                  containerPort: int  # 容器需要监听的端口号。
                  hostPort: int  # 容器所在主机需要监听的端口号，默认与 Container 相同。
                  protocol: string  # 端口协议，支持 TCP 和 UDP，默认 TCP。
              env: # 容器运行前需设置的环境变量列表。
                - name: string  # 环境变量名称。
                  value: string  # 环境变量的值。
              resources: # 资源限制和请求的设置。
                limits: # 资源限制的设置。
                  cpu: string  # cpu 的限制，单位为 core 数，将用于 docker run --cpu-shares 参数。
                  memory: string  # 内存限制，单位可以为 Mib/Gib，将用于 docker run --memory 参数。
                requests: # 资源请求的设置。
                  cpu: string  # cpu 请求，容器启动的初始可用数量。
                  memory: string  # 内存请求,容器启动的初始可用数量。
              lifecycle: # 生命周期钩子。
                postStart:  # 容器启动后立即执行此钩子,如果执行失败,会根据重启策略进行重启。
                preStop:  # 容器终止前执行此钩子,无论结果如何,容器都会终止。
              livenessProbe: # 对 Pod 内各容器健康检查的设置，当探测无响应几次后将自动重启该容器。
                exec: # 对 Pod 容器内检查方式设置为 exec 方式。
                  command: [ string ]  # exec 方式需要制定的命令或脚本。
                    httpGet: # 对 Pod 内个容器健康检查方法设置为 HttpGet，需要制定 Path、port。
                      path: string
                      port: number
                      host: string
                      scheme: string
                      HttpHeaders:
                        - name: string
                          value: string
                      tcpSocket: # 对 Pod 内个容器健康检查方式设置为 tcpSocket 方式。
                        port: number
                        initialDelaySeconds: 0  # 容器启动完成后首次探测的时间，单位为秒。
                        timeoutSeconds: 0  # 对容器健康检查探测等待响应的超时时间，单位秒，默认 1 秒。
                        periodSeconds: 0  # 对容器监控检查的定期探测时间设置，单位秒，默认 10 秒一次。
                        successThreshold: 0
                        failureThreshold: 0
                        securityContext:
                          privileged: false
                      restartPolicy: [ Always | Never | OnFailure ]  # Pod 的重启策略。
                        nodeName: >  # 设置 NodeName 表示将该 Pod 调度到指定到名称的 node 节点上。
                          nodeSelector: object  # 设置 NodeSelector 表示将该 Pod 调度到包含这个 label 的 node 上。
                          imagePullSecrets: # Pull 镜像时使用的 secret 名称，以 key：secretKey 格式指定。
                            - name: string
                          hostNetwork: false  # 是否使用主机网络模式，默认为 false，如果设置为 true，表示使用宿主机网络。
                          volumes: # 在该 pod 上定义共享存储卷列表。
                            - name: string  # 共享存储卷名称 （volumes 类型有很多种）。
                              emptyDir: { }  # 类型为 emptyDir 的存储卷，与 Pod 同生命周期的一个临时目录。为空值。
                              hostPath: string  # 类型为 hostPath 的存储卷，表示挂载 Pod 所在宿主机的目录。
                              path: string  # Pod 所在宿主机的目录，将被用于同期中 mount 的目录。
                              secret: # 类型为 secret 的存储卷，挂载集群与定义的 secret 对象到容器内部。
                                secretname: string
                                items:
                                  - key: string
                                    path: string
                              configMap: # 类型为 configMap 的存储卷，挂载预定义的 configMap 对象到容器内部。
                                name: string
                                items:
                                  - key: string
                                    path: string

# 小提示：
# 在这里，可通过一个命令来查看每种资源的可配置项。
# kubectl explain 资源类型				查看某种资源可以配置的一级属性。
# kubectl explain 资源类型.属性		查看属性的子属性。
[root@localhost k8s]# kubectl explain pod
KIND:     Pod
VERSION:  v1

DESCRIPTION:
     Pod is a collection of containers that can run on a host. This resource is
     created by clients and scheduled onto hosts.

FIELDS:
   apiVersion	<string>
     APIVersion defines the versioned schema of this representation of an
     object. Servers should convert recognized schemas to the latest internal
     value, and may reject unrecognized values. More info:
     https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources

   kind	<string>
     Kind is a string value representing the REST resource this object
     represents. Servers may infer this from the endpoint the client submits
     requests to. Cannot be updated. In CamelCase. More info:
     https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds

   metadata	<Object>
     Standard object's metadata. More info:
     https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata

   spec