Kubernetes(K8S)学习笔记

1、Kubernetes介绍

1.1 什么是Kubernetes

• Kubernetes是一个可移植的、可扩展的、开源的平台，用于管理容器化的工作负载和服务，它促进了声明式配置和自动化。它有一个庞大的、快速增长的生态系统。Kubernetes的服务、支持和工具可以广泛使用。

• Kubernetes这个名字源于希腊语，意思是舵手或飞行员。K8s作为一个缩写词，是计算“K”和“s”之间的八个字母的结果。谷歌于2014年开放Kubernetes项目。Kubernetes结合了谷歌超过15年的大规模运行生产负载的经验，以及来自社区的最佳品种的想法和实践。

 

1.2 容器化的发展历程

• 传统部署时代（Traditional Deployment era）：早期，APP之间运行在物理服务器上，无法为其中的应用程序定义资源边界，这就导致了资源分配 问题。例如，如果一个物理服务器上运行着多个应用程序，可能会出现一个应用程序占用大部分资源的情况下，从而影响其它程序的性能。如果一个应用程序发生了内存泄漏，最终可能会耗尽服务器的资源，从而导致所有应用程序都挂掉。解决方案是在不同的物理机器上运行每个应用程序。但是这样的话，会导致资源得不到充分利用，而且维护组织很多物理服务器的成本很高，因此这种方式无法扩展。

• 虚拟化部署时代（Virtualized Deployment era）：一种解决方案就是使用虚拟化。它允许在一个物理服务器的CPU上运行多个虚拟机（vm）。虚拟化运行应用程序在虚拟机之间隔离，一个应用程序的信息不能被另一个应用程序自由访问，从而提供了一定安全性。虚拟化可以更好地利用物理服务器中的资源，有着更好的伸缩性，因为可以轻松地添加或更新应用程序，降低硬件成本。使用虚拟化，可以将一组物理资源表示为一次性虚拟机的集群。每个VM都是一台完整的机器，在虚拟硬件之上运行所有组件，包括自己的操作系统，这样也会导致一部分的资源消耗。

• 容器化部署时代（Container Deployment era）：容器类似于vm，但是它们有宽松的隔离属性，可以在应用程序之间共享操作系统（OS）。因此，容器被认为是轻量级的。与vm类型，容器有自己的文件系统、共享CPU、内存、进程空间等。由于它们与底层基础设施解耦，因此可以跨云和OS发行版进行移植。

使用容器的优点：

• 应用程序创建和部署更敏捷：与使用vm相比，容器映像创建更加简单和高效。
• 持续开发、集成和部署：通过快速高效的回滚，提供可靠和频繁的容器映像构建和部署。
• 可观察性：不仅显示操作系统级别的信息和指标，还显示应用程序状态和其它信号。
• 跨平台、测试和生产环境的一致性：在笔记本电脑上和云中运行的环境是一样的。
• 云和操作系统发行版的可移植性：可在Ubuntu、RHEL、CoreOS、内部部署、主要的公共云以及其它任何地方运行。
• 以应用程序为中心的管理：将抽象级别从在虚拟硬件上运行操作系统提升到使用逻辑资源在操作系统上运行应用程序。
• 松散耦合、分布式、弹性、自由的微服务：应用程序被分解为更小、独立的部分，可以动态地部署和管理，而不是在一台大型、单一用途的机器上运行一个庞大的堆栈。
• 资源隔离：可预测的应用性能。
• 资源利用：效率高、密度大。

 

1.3 为什么需要K8S以及它能做什么

        容器是捆绑和运行应用程序的好方法。在生产环境中，我们需要管理运行应用程序的容器，并确保没有停机时间。例如，一个容器出现故障，则需要启动另一个容器，如果由系统自动发现来处理那不是更简单吗？这就是K8S拯救我们的方式。K8S为我们提供了一个能够弹性地运行分布式系统的框架。它负责应用程序的扩展和故障转移，提供部署模式等等。

K8S可以提供的服务：

• 服务发现和负载均衡（Service discovery and load balancing）：K8s可以使用DNS名称或它们的IP地址开放容器。如果一个容器的流量很大，K8s能够负载均衡和分配网络流量，从而使部署稳定。
• 存储编排（Storage orchestration）：K8s运行我们自动挂载选择的存储系统，如本地存储、公共云提供商等。
• 自动部署和回滚（Automated rollouts and rollbacks）：我们可以使用K8s自动化地为我们的部署创建新的容器，删除现有的容器，并将它们所有的资源采用到新容器中。
• 自动装箱（Automatic bin packing）：在K8s的集群中，告诉K8s每个容器需要多少CPU和内存，K8s可以将容器安装到节点上，以充分利用资源。
• 自愈（Self-healing）：K8s会重新启动挂掉的容器，替换容器。
• 机密和配置管理（Secret and configuration management）：K8s允许存储和管理敏感信息，如密码OAuth令牌和SSH密钥。在部署和更新机密文件和应用程序配置时无需重新构建容器映像。

 

2、Kubernetes简介

2.1 Kubernetes简介

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

        Kubernetes本质是一组服务器集群，它可以在集群的每个节点上运行特定的程序，来对节点中的容器进行管理。目的是实现资源管理的自动化。

 

2.2 Kubernetes组件

        一个Kubernetes集群主要由控制节点（Master）和 工作节点（Node）构成，每个节点上都会安装不同的组件。

Master：集群的控制平面，复制集群的决策：

ApiServer：资源操作的唯一入口，接受用户输入的命令，提供认证、授权、API注册和发现等机制。

Scheduler：负责集群资源调度，安装预定的调度策略将Pod调度到相应的Node节点上。

ControllerManager：负责维护集群的状态，比如程序部署安排、故障检测、自动扩展、滚动更新等。

Etcd：负责存储集群中各种资源对象的信息。

Node：集群的数据平面，负责为容器提供运行环境：

Kubelet：负责维护容器的生命周期，即通过控制Docker来创建、更新、销毁容器。

KubeProxy：负责提供集群内部的服务发现和负载均衡。

Docker：负责节点上容器的各种操作。

下面，以部署一个nginx服务来说明Kubernetes系统各个组件调用关系：

1. 首先要明确，一旦Kubernetes环境启动成功后，master和node都会将自身的信息存储到etcd数据库中。

2. 一个nginx服务的安装请求会首先被发送到master节点的ApiServer组件。

3. ApiServer组件会调用Scheduler组件来决定到的应该把这个服务安装到哪个node节点上，在此时，它会从Etcd读取各个node节点的信息，然后按照一定的算法进行选择，并将结果告知ApiServer。

4. ApiServer调用ControllerManager去调度Node节点安装Nginx服务。

5. Kubelet接收到指令后，会通知Docker，然后由Docker来启动一个nginx的Pod，Pod是Kubernetes的最小操作单元，容器必须跑在Pod中。

6. 至此，一个nginx服务就运行了，如果需要访问nginx，就需要通过Kube-proxy来对Pod产生访问的代理，这样，外界用户就可以访问集群中的nginx服务了。

2.3 Kubernetes中的概念

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

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

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

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

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

Label：标签，用来对Pod进行分类，同一类Pod会拥有相同的标签。

NameSpace：命名空间，用来隔离Pod的运行环境。

 

3、环境搭建

        本次环境搭建需要安装三台centos服务器（一主二从），然后在每台服务器中分别安装docker、kubeadm、kubelet、bubectl程序。

3.1 安装虚拟机

使用的虚拟机配置如下：

名称	IP地址	操作系统	配置
Master	192.168.226.168	centos7	2颗CPU 2G内存 50G硬盘
Node1	192.168.226.169	centos7	2颗CPU 2G内存 50G硬盘
Node2	192.168.226.170	centos7	2颗CPU 2G内存 50G硬盘

        

3.2 环境初始化

1）检查操作系统版本

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

2）主机域名解析

为了方便后面集群的直接调用，在这配置一下主机名解析。

# 编辑三台服务器的/etc/hosts文件，添加下面内容，ip和主机名要换成自己的
192.168.226.168 master
192.168.226.169 node1
192.168.226.170 node2

3）时间同步

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

# 启动chronyd
systemctl start chronyd

# 设置chronyd服务开机自启
systemctl enable chronyd

# 查看时间
date

4）禁用iptables和firewalld服务

Kubernetes和Docker在运行中会产生大量的iptables规则，为了不让系统规则与他们混淆，直接关闭系统的规则。

# 关闭firewalld服务
systemctl stop firewalld
systemctl disable firewalld

# 关闭iptables服务
systemctl stop iptables
systemctl disable iptables

5）禁用selinux

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

# 编辑 /etc/selinux/config文件，修改SELINUX的值为disabled
SELINUX=disabled
# 修改完后需要重新启动linux，可以在执行完后面操作后统一重启

6）禁用swap分区

swap分区指的是虚拟内存分区，它的作用是在物理内存使用完之后，将磁盘空间虚拟成内存在使用。

启用swap设备会对系统的性能产生非常负面的影响，因此Kubernetes要求每个节点都要禁用swap设备。

但是如果因为某些原因确实不能关闭swap分区，就需要在集群安装过程中通过明确的参数进行配置说明。

# 编辑分区配置文件 /etc/fstab ，注释掉swap分区一行
# 注意修改后要重启linux
/dev/mapper/centos-root /                       xfs     defaults        0 0
UUID=1b419f2d-536b-4728-a6d2-c8b9d7ea85f0 /boot                   xfs     defaults        0 0
#/dev/mapper/centos-swap swap                    swap    defaults        0 0

7）修改linux内核参数

# 修改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

# 重新加载配置
sysctl -p

# 加载网桥过滤模块
modprobe br_netfilter

# 查看网桥过滤模块是否加载成功
lsmod | grep br_netfilter

[root@master ~]# lsmod | grep br_netfilter
br_netfilter           22256  0 
bridge                151336  1 br_netfilter

8）配置ipvs功能

在kubernetes中service有两种代理模型，一种基于iptables的，一种基于ipvs的

两者比较的话，ipvs的性能明显要高一些，但是如果要使用它，需要手动载入ipvs模块

# 1.安装ipset和ipvsadm
yum install -y ipset ipvsadm

# 2.添加需要加载的模块写入脚本
cat <<EOF > /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

# 3.为脚本文件添加执行权限
chmod +x /etc/sysconfig/modules/ipvs.modules

# 4.执行脚本文件
/bin/bash /etc/sysconfig/modules/ipvs.modules

# 5.查看对应的模块是否加载成功
lsmod | grep -e ip_vs -e nf_conntrack_ipv4

[root@master ~]# 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

9）重启linux

reboot

# 重启后查看selinux
[root@master ~]# getenforce
Disabled

# 查看swap分区情况,swap全是0代表已经关掉了
[root@master ~]# free -m
              total        used        free      shared  buff/cache   available
Mem:           3770         271        3174          11         324        3271
Swap:             0           0           0

至此环境初始化已经完成了！

        

3.3 Docker安装

# 1.更新镜像源
$ yum -y update

# 2.安装所需的软件包。yum-utils 提供了 yum-config-manager ，并且 device mapper 存储驱动程序需要 device-mapper-persistent-data 和 lvm2。
$ sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2
  
# 3.使用阿里云镜像源
$ sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 4.安装最新版本的 Docker Engine-Community 和 containerd
$ sudo yum install docker-ce docker-ce-cli containerd.io

# 5.添加配置文件
# Docker在默认情况下使用的Cgroup Driver为cgroupfs，而kubernetes推荐使用systemd来代替cgroupfs
mkdir /etc/docker
cat <<EOF > /etc/docker/daemon.json
{
  "exec-opts":["native.cgroupdriver=systemd"],
  "registry-mirrors": ["https://kn0t2bca.mirror.aliyuncs.com"]
}
EOF

# 6.启动Docker
$ sudo systemctl restart docker

# 7.设置docker开机自启
$ sudo systemctl enable docker 

# 8.运行hello-world测试是否安装成功
$ docker run hello-world

        

3.4 安装Kubernetes组件

# 由于Kubernetes的镜像源在国外，速度比较慢，这里切换成国内的镜像源
# 编辑/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/rpm-package-key.gpg
        https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
        
# 安装kubeadm、kubelet和kubectl
yum install -y kubelet kubeadm kubectl 

# 配置kubelet的cgroup
# 编辑/etc/sysconfig/kubelet,添加如下配置
KUBELET_CGROUP_ARGS="--cgroup-driver=systemd"
KUBE_PROXY_MODE="ipvs"

# 设置kubelet开机自启
systemctl enable kubelet

        

3.5 准备集群镜像

# 在安装kubernetes集群之前，必须要提前准备好集群所需的镜像，所需镜像可以通过下面命令查看
kubeadm config images list

# 下载镜像
# 此镜像在k8s的仓库中，由于网络原因，无法连接，下面提供了一种代替方案
# 我们从阿里云拉取镜像，然后给镜像打上k8s官方的tag，这样他就不会从k8s仓库中拉取了
# 在shell中输入下面命令即可
images=(
	kube-apiserver:v1.23.1
	kube-controller-manager:v1.23.1
	kube-scheduler:v1.23.1
	kube-proxy:v1.23.1
	pause:3.6
	etcd:3.5.1-0
	coredns:v1.8.6	
)

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

docker pull registry.aliyuncs.com/google_containers/coredns:v1.8.6
docker tag registry.aliyuncs.com/google_containers/coredns:v1.8.6 k8s.gcr.io/coredns/coredns:v1.8.6
docker rmi registry.aliyuncs.com/google_containers/coredns:v1.8.6

# 执行完毕后可以查看镜像
[root@master ~]# docker images
REPOSITORY                                        TAG       IMAGE ID       CREATED        SIZE
k8s.gcr.io/kube-apiserver                         v1.23.1   b6d7abedde39   3 weeks ago    135MB
k8s.gcr.io/kube-proxy                             v1.23.1   b46c42588d51   3 weeks ago    112MB
k8s.gcr.io/kube-controller-manager                v1.23.1   f51846a4fd28   3 weeks ago    125MB
k8s.gcr.io/kube-scheduler                         v1.23.1   71d575efe628   3 weeks ago    53.5MB
k8s.gcr.io/etcd                                   3.5.1-0   25f8c7f3da61   2 months ago   293MB
k8s.gcr.io/coredns                                v1.8.6    a4ca41631cc7   3 months ago   46.8MB
registry.aliyuncs.com/google_containers/coredns   v1.8.6    a4ca41631cc7   3 months ago   46.8MB
hello-world                                       latest    feb5d9fea6a5   3 months ago   13.3kB
k8s.gcr.io/pause 

        

3.6 集群初始化

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

# 创建集群, 第一个版本可能需要改成你自己的版本，最后一个是master节点的ip地址，需要改成自己的
kubeadm init \
--kubernetes-version=v1.23.1 \
--pod-network-cidr=10.244.0.0/16 \
--service-cidr=10.96.0.0/12 \
--apiserver-advertise-address=192.168.226.168   

# 显示下面这句话说明运行成功
Your Kubernetes control-plane has initialized successfully!

# 然后执行如下命令
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

其它节点加入集群

# 在其他节点上加入集群
# 在master节点上使用下面的命令可以查看加入集群的命令
kubeadm token create --print-join-command

# 然后复制命令，在其它节点上执行
[root@master ~]# kubeadm token create --print-join-command
kubeadm join 192.168.226.168:6443 --token iopvlm.1fdztldlifhh7ej9 --discovery-token-ca-cert-hash sha256:1ce8f02b795807f4c16532da3e1ea2b798e01e6580a59b419abd825d90af8a7d 

# 在master节点上查看加入的节点
[root@master ~]# kubectl get nodes
NAME     STATUS     ROLES                  AGE   VERSION
master   NotReady   control-plane,master   12m   v1.23.1
node1    NotReady   <none>                 21s   v1.23.1
node2    NotReady   <none>                 14s   v1.23.1

状态显示NotReady，是因为网络插件还没有安装，下面安装网络插件
        

3.7 安装网络插件

K8s支持多种网络插件，比如flannel、calico、canal等，任选一种使用即可，在此选择flannel

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

# 获取flannel的配置文件
# 配置文件在下面

# 使用配置文件启动flannel
kubectl apply -f kube-flannel.yml

# 稍等片刻，再次查看集群节点的状态
kubectl get nodes

flannel配置文件

---
apiVersion: policy/v1beta1
kind: PodSecurityPolicy
metadata:
  name: psp.flannel.unprivileged
  annotations:
    seccomp.security.alpha.kubernetes.io/allowedProfileNames: docker/default
    seccomp.security.alpha.kubernetes.io/defaultProfileName: docker/default
    apparmor.security.beta.kubernetes.io/allowedProfileNames: runtime/default
    apparmor.security.beta.kubernetes.io/defaultProfileName: runtime/default
spec:
  privileged: false
  volumes:
  - configMap
  - secret
  - emptyDir
  - hostPath
  allowedHostPaths:
  - pathPrefix: "/etc/cni/net.d"
  - pathPrefix: "/etc/kube-flannel"
  - pathPrefix: "/run/flannel"
  readOnlyRootFilesystem: false
  # Users and groups
  runAsUser:
    rule: RunAsAny
  supplementalGroups:
    rule: RunAsAny
  fsGroup:
    rule: RunAsAny
  # Privilege Escalation
  allowPrivilegeEscalation: false
  defaultAllowPrivilegeEscalation: false
  # Capabilities
  allowedCapabilities: ['NET_ADMIN', 'NET_RAW']
  defaultAddCapabilities: []
  requiredDropCapabilities: []
  # Host namespaces
  hostPID: false
  hostIPC: false
  hostNetwork: true
  hostPorts:
  - min: 0
    max: 65535
  # SELinux
  seLinux:
    # SELinux is unused in CaaSP
    rule: 'RunAsAny'
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: flannel
rules:
- apiGroups: ['extensions']
  resources: ['podsecuritypolicies']
  verbs: ['use']
  resourceNames: ['psp.flannel.unprivileged']
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - get
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - list
  - watch
- apiGroups:
  - ""
  resources:
  - nodes/status
  verbs:
  - patch
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: flannel
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: flannel
subjects:
- kind: ServiceAccount
  name: flannel
  namespace: kube-system
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: flannel
  namespace: kube-system
---
kind: ConfigMap
apiVersion: v1
metadata:
  name: kube-flannel-cfg
  namespace: kube-system
  labels:
    tier: node
    app: flannel
data:
  cni-conf.json: |
    {
      "name": "cbr0",
      "cniVersion": "0.3.1",
      "plugins": [
        {
          "type": "flannel",
          "delegate": {
            "hairpinMode": true,
            "isDefaultGateway": true
          }
        },
        {
          "type": "portmap",
          "capabilities": {
            "portMappings": true
          }
        }
      ]
    }
  net-conf.json: |
    {
      "Network": "10.244.0.0/16",
      "Backend": {
        "Type": "vxlan"
      }
    }
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kube-flannel-ds
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  selector:
    matchLabels:
      app: flannel
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/os
                operator: In
                values:
                - linux
      hostNetwork: true
      priorityClassName: system-node-critical
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay-mirror.qiniu.com/coreos/flannel:v0.13.1-rc1
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay.io/coreos/flannel:v0.13.1-rc1
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: false
          capabilities:
            add: ["NET_ADMIN", "NET_RAW"]
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run/flannel
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
      - name: run
        hostPath:
          path: /run/flannel
      - name: cni
        hostPath:
          path: /etc/cni/net.d
      - name: flannel-cfg
        configMap:
          name: kube-flannel-cfg

        

3.8 服务部署

接下来在k8s集群中部署一个nginx程序，测试下集群是否正常工作。

# 部署nginx
kubectl create deployment nginx --image=nginx:1.14-alpine

# 暴露端口
kubectl expose deployment nginx --port=80 --type=NodePort

# 查看服务状态
[root@master ~]# kubectl get pods,service
NAME                         READY   STATUS    RESTARTS   AGE
pod/nginx-7cbb8cd5d8-hhnmg   1/1     Running   0          2m11s

NAME                 TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
service/kubernetes   ClusterIP   10.96.0.1      <none>        443/TCP        68m
service/nginx        NodePort    10.96.52.227   <none>        80:30041/TCP   31m

# 最后在电脑上访问nginx
# 输入master主机的ip和上面最后一条中的30041端口

        

3.9 可能产生的问题

使用 kubectl get pod -n kube-system可以查看系统pod的启动情况：

[root@master k8s]# kubectl get pods -n kube-system
NAME                             READY   STATUS                  RESTARTS      AGE
coredns-64897985d-6w7vv          0/1     ImagePullBackOff        0             44s
coredns-64897985d-b577t          0/1     ImagePullBackOff        0             44s
etcd-master                      1/1     Running                 0             22h
kube-apiserver-master            1/1     Running                 0             22h
kube-controller-manager-master   1/1     Running                 2 (17h ago)   22h
kube-flannel-ds-amd64-dkh9p      1/1     Running                 7 (21h ago)   21h
kube-flannel-ds-amd64-hx9v4      1/1     Running                 7 (21h ago)   21h
kube-flannel-ds-amd64-m684w      1/1     Running                 7 (21h ago)   21h
kube-flannel-ds-b9xc9            0/1     Init:ImagePullBackOff   0             21h
kube-flannel-ds-pft6v            0/1     Init:ImagePullBackOff   0             21h
kube-flannel-ds-t22gs            0/1     Init:ImagePullBackOff   0             21h
kube-proxy-4kg5z                 1/1     Running                 0             22h
kube-proxy-c4xqw                 1/1     Running                 0             22h
kube-proxy-rkdf5                 1/1     Running                 0             22h
kube-scheduler-master            1/1     Running                 2 (17h ago)   22h

        可以看到coredns和flannel都没有启动成功，状态是ImagePullBackOff，说明镜像拉取失败，但是明明本地已经下载了镜像。看来应该是标签名不一致，所以它又去拉取，而且没有成功，因此我们需要把本地的镜像打一个新的标签。

使用 kubectl get pod -n kube-system -o wide可以查看详情：

[root@master k8s]# kubectl get pods -n kube-system -o wide
NAME                             READY   STATUS                  RESTARTS      AGE   IP                NODE     NOMINATED NODE   READINESS GATES
coredns-64897985d-6w7vv          0/1     ImagePullBackOff        0             92s   10.244.2.10       node2    <none>           <none>
coredns-64897985d-b577t          0/1     ImagePullBackOff        0             92s   10.244.1.6        node1    <none>           <none>
etcd-master                      1/1     Running                 0             22h   192.168.226.168   master   <none>           <none>
kube-apiserver-master            1/1     Running                 0             22h   192.168.226.168   master   <none>           <none>
kube-controller-manager-master   1/1     Running                 2 (17h ago)   22h   192.168.226.168   master   <none>           <none>
kube-flannel-ds-amd64-dkh9p      1/1     Running                 7 (21h ago)   21h   192.168.226.170   node2    <none>           <none>
kube-flannel-ds-amd64-hx9v4      1/1     Running                 7 (21h ago)   21h   192.168.226.169   node1    <none>           <none>
kube-flannel-ds-amd64-m684w      1/1     Running                 7 (21h ago)   21h   192.168.226.168   master   <none>           <none>
kube-flannel-ds-b9xc9            0/1     Init:ImagePullBackOff   0             21h   192.168.226.170   node2    <none>           <none>
kube-flannel-ds-pft6v            0/1     Init:ErrImagePull       0             21h   192.168.226.168   master   <none>           <none>
kube-flannel-ds-t22gs            0/1     Init:ImagePullBackOff   0             21h   192.168.226.169   node1    <none>           <none>
kube-proxy-4kg5z                 1/1     Running                 0             22h   192.168.226.169   node1    <none>           <none>
kube-proxy-c4xqw                 1/1     Running                 0             22h   192.168.226.170   node2    <none>           <none>
kube-proxy-rkdf5                 1/1     Running                 0             22h   192.168.226.168   master   <none>           <none>
kube-scheduler-master            1/1     Running                 2 (17h ago)   22h   192.168.226.168   master   <none>           <none>

通过查看，发现node1和node2的coredns没有启动成功，master和两个node的flannel都没有启动成功。

使用 kubectl describe pod kube-flannel-ds-b9xc9 -n kube-system | grep Image:来查看需要的镜像名。

[root@master k8s]# kubectl describe pod kube-flannel-ds-b9xc9 -n kube-system | grep Image:
    Image:         quay-mirror.qiniu.com/coreos/flannel:v0.13.1-rc1
    Image:         quay.io/coreos/flannel:v0.13.1-rc1

然后使用docker tag 原标签名 目的标签名来修改标签名即可。

然后这些没有启动的pod就会重启，或者也可以删掉pod，删掉后会重新启动，命令为：

kubectl delete pod pod名 -n kube-system

 

4、资源管理

4.1 资源管理介绍

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

​ Kubernetes的本质就是一个集群系统，用户可以在集群中部署各种服务，所谓的部署服务，其实就是在Kubernetes集群中运行一个个的容器，并将指定的程序跑在容器中。

​ Kubernetes的最小管理单元是Pod而不是容器，所以只能将容器放在Pod中，而Kubernetes一般也不会直接管理Pod，而是通过pod控制器来管理Pod的。

​ Pod可以提供服务之后，就需要考虑如何访问Pod中的服务，Kubernetes提供了Service资源实现这个功能。

​ 当然，如果Pod中程序的数据需要持久化，Kubernetes还提供了各种存储系统。

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

        

4.2 Yaml语法介绍

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

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

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

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

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

# 纯量，就是指的一个简单的值，字符串、布尔、整数、浮点数、Null、时间、日期
# 布尔类型
c1: true
# 整型
c2: 123456
# 浮点类型
c3: 3.14
# null类型
c4: ~ # 使用~表示null
# 日期类型
c5: 2019-11-11 # 日期类型必须使用ISO 8601格式，即yyyy-MM-dd
# 时间类型
c6: 2019-11-11T15:02:31+08.00 # 时间类型使用ISO 8601格式，时间和日期之间使用T连接，最后使用+代表时区
# 字符串类型
c7: haha # 简单写法，直接写值，如果字符串中间有特殊符号，必须使用双引号或单引号包裹
c8: line1
    line2 # 字符串过多的情况可以折成多行，每一行都会转换成一个空格

# 对象
# 形式一（推荐）：
xudaxian:	
	name: kunkun
	age: 30
# 形式二（了解）：
xuxian: { name: jige, age: 30 }

# 数组
# 形式一（推荐）：
address:
	- 江苏
	- 浙江
# 形式二（了解）：
address: [江苏,上海]

小提示：

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

​ 2 如果需要将多段yaml配置放在一个文件中，中间要用---分割

        

4.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

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

4.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，以json格式展示结果
kubectl get pod pod_name -o json

·操作·

        Kubernetes运行对资源进行多种操作，可以通过kubectl --help来查看详细的操作命令

查用操作如下：

① 基本命令

命令	翻译	命令作用
create	创建	创建一个资源
edit	编辑	编辑一个资源
get	获取	获取一个资源
patch	更新	更新一个资源
delete	删除	删除一个资源
explain	解释	展示资源文档

② 运行和调试

命令	翻译	命令作用
run	运行	在集群中运行一个指定的镜像
expose	暴露	暴露资源为Service
describe	描述	显示资源内部信息
logs	日志	输出容器在Pod中的日志
attach	缠绕	进入运行中的容器
exec	执行	执行容器中的一个命令
cp	复制	在Pod内外复制文件
rollout	首次展示	管理资源的发布
scale	规模	扩（缩）容Pod的数量
autoscale	自动调整	自动调整Pod的数量

③ 高级命令

命令	翻译	命令作用
apply	应用	通过文件对资源进行配置
label	标签	更新资源上的标签

④ 其它命令

命令	翻译	命令作用
apply	应用	通过文件对资源进行配置
label	标签	更新资源上的标签

·资源类型·

        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		配置

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

# 创建一个namespace, namespace可以缩写为ns
[root@master ~]# kubectl create namespace dev
namespace/dev created

# 查看namespace
[root@master ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   20h
dev               Active   40s
kube-node-lease   Active   20h
kube-public       Active   20h
kube-system       Active   20h

# 在此namespace下创建并运行一个nginx的pod,-n 用来指定命名空间
[root@master ~]# kubectl run pod --image=nginx:1.17.1 -n dev
pod/pod created

# 查看新创建的pod
[root@master ~]# kubectl get pod -n dev
NAME   READY   STATUS    RESTARTS   AGE
pod    1/1     Running   0          36s

# 删除指定的pod
[root@master ~]# kubectl delete pod pod -n dev
pod "pod" deleted

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

4.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@master k8s]# kubectl create -f nginxpod.yaml 
namespace/dev created
pod/nginxpod created

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

3）执行get命令查看资源：

[root@master k8s]# kubectl get -f nginxpod.yaml
NAME            STATUS   AGE
namespace/dev   Active   93s

NAME           READY   STATUS    RESTARTS   AGE
pod/nginxpod   1/1     Running   0          93s

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

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

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

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

​ 总结：

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

4.3.3 声明式对象配置

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

# 首先执行一次kubectl apply -f nginxpod.yaml文件，发现创建了资源
[root@master k8s]# kubectl apply -f nginxpod.yaml 
namespace/dev created
pod/nginxpod created

# 再次执行，发现资源没有变动
[root@master k8s]# kubectl apply -f nginxpod.yaml 
namespace/dev unchanged
pod/nginxpod unchanged

总结：

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

        使用apply操作资源：

                如果资源不存在，就创建，相当于 kubectl create

                如果资源已存在，就更新，相当于 kubectl patch

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

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

scp -r ~/.kube/ node1:~/

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

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

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

查询资源： 使用命令式对象管理 kubectl get / describe 资源名称

 

5、实战入门

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

5.1 Namespace

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

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

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

Kubernetes在集群启动后，会默认创建几个Namespace

# namespace 也可以缩写为 ns
[root@master k8s]# kubectl get namespace            
NAME              STATUS   AGE
default           Active   46h
kube-node-lease   Active   46h
kube-public       Active   46h
kube-system       Active   46h

下面来看Namespace资源的具体操作：

查看：

# 1.查看所有的namespace
[root@master k8s]# kubectl get ns
NAME              STATUS   AGE
default           Active   46h
dev               Active   41m
kube-node-lease   Active   46h
kube-public       Active   46h
kube-system       Active   46h

# 2.查看指定的ns
[root@master k8s]# kubectl get ns kube-system
NAME          STATUS   AGE
kube-system   Active   46h

# 3.指定输出格式 命令：kubectl get ns ns名称 -o 格式参数
# 格式参数有很多，比较常见的是 wide、json、yaml
[root@master k8s]# kubectl get ns default -o json
{
    "apiVersion": "v1",
    "kind": "Namespace",
    "metadata": {
        "creationTimestamp": "2022-01-06T13:14:23Z",
        "labels": {
            "kubernetes.io/metadata.name": "default"
        },
        "name": "default",
        "resourceVersion": "207",
        "uid": "5a0e80e3-24de-4e83-8748-7b5e777dd4c7"
    },
    "spec": {
        "finalizers": [
            "kubernetes"
        ]
    },
    "status": {
        "phase": "Active"
    }
}

# 4.查看ns详情 命令： kubectl describe ns ns名称
[root@master k8s]# kubectl describe ns default
Name:         default
Labels:       kubernetes.io/metadata.name=default
Annotations:  <none>
Status:       Active

No resource quota.

No LimitRange resource.

创建：

# 创建namespace
[root@master k8s]# kubectl create ns test
namespace/test created

删除：

# 删除namespace
[root@master k8s]# kubectl delete ns test
namespace "test" deleted

配置方式：

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

apiVersion: v1
kind: Namespace
metadata:
  name: dev

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

创建 kubectl create -f ns-dev.yaml

删除 kubectl delete -f ns-dev.yaml

        

5.2 Pod

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

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

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

[root@master k8s]# kubectl get pod -n kube-system
NAME                             READY   STATUS    RESTARTS      AGE
coredns-64897985d-hgmnd          1/1     Running   0             24h
coredns-64897985d-wrqs4          1/1     Running   0             24h
etcd-master                      1/1     Running   0             47h
kube-apiserver-master            1/1     Running   0             47h
kube-controller-manager-master   1/1     Running   2 (41h ago)   47h
kube-flannel-ds-amd64-dkh9p      1/1     Running   7 (46h ago)   46h
kube-flannel-ds-amd64-hx9v4      1/1     Running   7 (46h ago)   46h
kube-flannel-ds-amd64-m684w      1/1     Running   7 (46h ago)   46h
kube-flannel-ds-b9xc9            1/1     Running   0             46h
kube-flannel-ds-pft6v            1/1     Running   0             46h
kube-flannel-ds-t22gs            1/1     Running   0             46h
kube-proxy-4kg5z                 1/1     Running   0             46h
kube-proxy-c4xqw                 1/1     Running   0             46h
kube-proxy-rkdf5                 1/1     Running   0             47h
kube-scheduler-master            1/1     Running   2 (41h ago)   47h

创建并运行：

Kubernetes没有提供单独允许Pod的命令，都是通过Pod控制器来实现的

# 命令格式： kubectl run (pod控制器名称) [参数]
# --image 指定Pod的jingx
# --port 指定端口
# --namespace 指定命名空间
[root@master k8s]# kubectl run nginx-test --image=nginx:1.17.1 --port=80 --namespace=dev
pod/nginx-test created

查看Pod信息：

# 查看pod基本信息
[root@master k8s]# kubectl get pod -n dev
NAME                     READY   STATUS    RESTARTS   AGE
nginx-6fdfb7f689-ht222   1/1     Running   0          40m
nginx-6fdfb7f689-q2wjx   1/1     Running   0          40m
nginx-6fdfb7f689-xklcw   1/1     Running   0          40m
nginx-test               1/1     Running   0          54s

# 查看详细信息
[root@master k8s]# kubectl get pod -n dev -o wide
NAME                     READY   STATUS    RESTARTS   AGE   IP            NODE    NOMINATED NODE   READINESS GATES
nginx-6fdfb7f689-ht222   1/1     Running   0          41m   10.244.1.15   node1   <none>           <none>
nginx-6fdfb7f689-q2wjx   1/1     Running   0          41m   10.244.2.14   node2   <none>           <none>
nginx-6fdfb7f689-xklcw   1/1     Running   0          41m   10.244.1.14   node1   <none>           <none>
nginx-test               1/1     Running   0          76s   10.244.1.16   node1   <none>           <none>

# 查看某个pod的更详细信息,最下面记录了Pod的启动日志，可以用此来排错
[root@master k8s]# kubectl describe pod nginx-test -n dev
Name:         nginx-test
Namespace:    dev
Priority:     0
Node:         node1/192.168.226.169
Start Time:   Sat, 08 Jan 2022 20:23:54 +0800
Labels:       run=nginx-test
Annotations:  <none>
Status:       Running
IP:           10.244.1.16
IPs:
  IP:  10.244.1.16
Containers:
  nginx-test:
    Container ID:   docker://d8419946e6348a3f5297ec3b30675e9aa27639c853d68b5a4e9bd334ef709924
    Image:          nginx:1.17.1
    Image ID:       docker-pullable://nginx@sha256:b4b9b3eee194703fc2fa8afa5b7510c77ae70cfba567af1376a573a967c03dbb
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Sat, 08 Jan 2022 20:23:55 +0800
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-fnf59 (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  kube-api-access-fnf59:
    Type:                    Projected (a volume that contains injected data from multiple sources)
    TokenExpirationSeconds:  3607
    ConfigMapName:           kube-root-ca.crt
    ConfigMapOptional:       <nil>
    DownwardAPI:             true
QoS Class:                   BestEffort
Node-Selectors:              <none>
Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                             node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type    Reason     Age    From               Message
  ----    ------     ----   ----               -------
  Normal  Scheduled  2m20s  default-scheduler  Successfully assigned dev/nginx-test to node1
  Normal  Pulled     2m20s  kubelet            Container image "nginx:1.17.1" already present on machine
  Normal  Created    2m20s  kubelet            Created container nginx-test
  Normal  Started    2m20s  kubelet            Started container nginx-test

删除指定的Pod：

# 删除指定pod
[root@master k8s]# kubectl delete pod nginx-test -n dev
pod "nginx-test" deleted

# 此时，显示删除成功，但是再次查询，发现可能新产生了一个
# 如果是旧版本，可以会产生一个新的，新版本则不会产生。
# 说明，新版本使用run命令创建的pod没有Pod控制器。
# 在旧版本中，使用run命令会产生一个Pod控制器，该控制器会监控Pod的状态，一旦Pod被删除，Pod控制器
# 就会创建一个新的Pod

# 查看Pod控制器
kubectl get deploy -n dev

配置操作：

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

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

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

创建： kubectl create -f pod-nginx.yaml

删除： kubectl delete -f pod-nginx.yaml

        

5.3 Label

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

Label的特定：

• 一个Label会以key/value键值对的形式附加到各种对象上，如Node、Pod、Service等
• 一个资源对象可以定义任意数量的Label，同一个Lable也可以被添加到任意数量的资源对象上去。
• 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 int (frontend)：选择所有包含Label中的key="env"且value不等于"frontend"的对象

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

    name=slave, env!=production

​    name not in (frontend), env!=production

命令格式：

# 为pod资源打标签
[root@master k8s]# kubectl label pod nginx-test version=1.0 -n dev
pod/nginx-test labeled

# 为pod资源更新标签
[root@master k8s]# kubectl label pod nginx-test version=2.0 -n dev --overwrite
pod/nginx-test labeled

# 查看标签
[root@master k8s]# kubectl get pod nginx-test -n dev --show-labels
NAME         READY   STATUS    RESTARTS   AGE   LABELS
nginx-test   1/1     Running   0          14m   version=2.0

# 筛选标签
[root@master k8s]# kubectl get pod -n dev -l version=2.0 --show-labels
NAME         READY   STATUS    RESTARTS   AGE   LABELS
nginx-test   1/1     Running   0          15m   version=2.0
[root@master k8s]# kubectl get pod -n dev -l version!=2.0 --show-labels
NAME                     READY   STATUS    RESTARTS   AGE   LABELS
nginx-6fdfb7f689-ht222   1/1     Running   0          70m   pod-template-hash=6fdfb7f689,run=nginx

# 删除标签
[root@master k8s]# kubectl label pod nginx-test -n dev version-
pod/nginx-test unlabele

配置方式：

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

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

        

5.4 Deployment

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

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

命令操作：

# 命令格式： kubectl create deployment deployment名称 [参数]
# --image 指定pod的镜像
# --port 指定端口
# --replicas 指定副本数量
# --namespace 指定namespace
[root@master k8s]# kubectl create deploy nginx --image=nginx:1.17.1 --port=80 --replicas=3 --namespace=dev
deployment.apps/nginx created

# 查看创建的pod
[root@master k8s]# kubectl get pod -n dev
NAME                     READY   STATUS    RESTARTS   AGE
nginx-78bc4f47cf-6tdr7   1/1     Running   0          24s
nginx-78bc4f47cf-bxwp2   1/1     Running   0          24s
nginx-78bc4f47cf-srm7m   1/1     Running   0          24s

# 查看deployment
[root@master k8s]# kubectl get deploy -n dev
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
nginx   3/3     3            3           70s

# UP-TO-DATE：成功升级的副本数量
# AVAILABLE：可以副本数量
[root@master k8s]# kubectl get deploy -n dev -o wide
NAME    READY   UP-TO-DATE   AVAILABLE   AGE     CONTAINERS   IMAGES         SELECTOR
nginx   3/3     3            3           2m16s   nginx        nginx:1.17.1   app=nginx

# 查看deployment的详细信息
[root@master k8s]# kubectl describe deploy nginx -n dev
Name:                   nginx
Namespace:              dev
CreationTimestamp:      Sat, 08 Jan 2022 21:04:09 +0800
Labels:                 app=nginx
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=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:  app=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-78bc4f47cf (3/3 replicas created)
Events:
  Type    Reason             Age    From                   Message
  ----    ------             ----   ----                   -------
  Normal  ScalingReplicaSet  2m45s  deployment-controller  Scaled up replica set nginx-78bc4f47cf to 3
 
 
# 删除deployment
[root@master k8s]# kubectl delete deploy nginx -n dev
deployment.apps "nginx" deleted

配置操作：

创建一个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

然后使用create或apply命令来创建，delete命令来更新即可

        

5.5 Service

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

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

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

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

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

操作一：创建集群内部可访问的Service

# 暴露Service,service可以缩写为svc
[root@master k8s]# kubectl expose deploy nginx --name=svc-nginx --type=ClusterIP --port=80 --target-port=80 -n dev
service/svc-nginx exposed

# 查看Service
[root@master k8s]# kubectl get svc -n dev
NAME        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)   AGE
svc-nginx   ClusterIP   10.111.174.153   <none>        80/TCP    22s

# 这里产生了一个CLUSTER-IP，这就是Service的IP，在Service的生命周期中，这个地址是不会变的
# 可以通过这个IP访问当前Service对应的Pod
[root@master k8s]# curl 10.111.174.153: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>

操作二：创建集群外部也可访问的Service

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

# 此时查看，会发现出现了NodePort类型的Service，而且有一对port（80:30248）
[root@master k8s]# kubectl get svc -n dev
NAME         TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
svc-nginx    ClusterIP   10.111.174.153   <none>        80/TCP         4m58s
svc-nginx1   NodePort    10.99.100.168    <none>        80:30248/TCP   20s

# 接下来就可以通过集群外的主机访问节点IP:30248服务了
# 可以通过任意一个节点的IP:30248来访问

配置方式：

创建一个svc-nginx.yaml的文件，内容如下：

apiVersion: v1
kind: Service
metadata:
  name: svc-nginx
  namespace: dev
spec:
  clusterIP: 10.97.241.231
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: nginx
  type: ClusterIP

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

创建 kubectl create -f svc-nginx.yaml

删除 kubectl delete -f svc-nginx.yaml

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

 

6、Pod详解

本章节将详细介绍Pod资源的各种配置和原理。
        

6.1 Pod介绍

6.1.1 Pod结构

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

• 用户程序所在的容器，数量可多可少
• Pause容器，这是每个Pod都会有的一个根容器，它的作用有两个：
  • 可以以它为凭据，评估整个Pod的健康状态。
  • 可以在根容器上设置Ip地址，其它容器使用此IP，以实现Pod内部的网络通信

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

6.1.2 Pod定义

下面是Pod的资源清单：

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

# 小提示
# 在这里，可以通过一个命令来查看每种资源的可配置项
# kubectl explain 资源类型                 查看某种资源可以配置的一级属性
# kubectl explain 资源类型.属性             查看属性的子属性
[root@master 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:

   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:

   metadata     <Object>
     Standard object's metadata. More info:

   spec