Kubernetes是一个开源的容器编排工具，专为自动化容器化应用程序的部署、扩展和管理而设计。它通过提供一种灵活的、可扩展的解决方案，帮助开发者和运维人员简化应用程序的管理流程。Kubernetes由Google开发，现在由云原生计算基金会（CNCF）维护。

在过去，应用程序通常以单体架构部署，这种方式存在一定的局限性，如更新和扩展困难。随着容器化技术的兴起，微服务架构成为主流，每个服务独立部署在自己的容器中。然而，随着容器数量的增加，管理这些容器变得非常复杂，这时就需要一个强大的编排工具来解决这个问题。Kubernetes应运而生，提供了自动化管理容器的能力。

Kubernetes不仅简化了容器化应用的管理，还支持自动扩展、自我修复和滚动更新等特性，使得应用程序可以更可靠地运行在生产环境中。它的跨云能力也使得应用可以轻松迁移到不同的云平台，提高了灵活性和可移植性。

本文瑞哥带大家好好了解一下Kubernetes。

Kubernetes 的基本概念

容器

容器是一种轻量级的虚拟化技术，它将应用程序及其依赖项打包在一起，在独立的环境中运行。相比传统的虚拟机，容器具有更高的资源利用率和更快的启动速度。

容器编排

随着应用程序的规模和复杂度增加，手动管理大量容器变得不可行。容器编排工具（如Kubernetes）通过自动化部署、管理和扩展容器，帮助运维人员高效地管理应用程序。

Kubernetes集群

Kubernetes集群由一组节点组成，包括一个或多个控制平面节点和若干工作节点。控制平面节点负责管理集群的整体状态，而工作节点负责实际运行容器化的应用程序。

Kubernetes架构总览

Kubernetes的架构包括以下主要组件：

• 控制平面（Control Plane）：包括kube-apiserver、etcd、kube-scheduler、kube-controller-manager和cloud-controller-manager。控制平面负责管理集群的状态、调度Pod到合适的节点、监控节点和Pod的健康状况等。它是集群的大脑。
• 工作节点（Worker Nodes）：包括kubelet、kube-proxy和容器运行时。工作节点则负责运行实际的应用容器，每个工作节点都有一个kubelet进程来管理节点上的Pod，还有一个kube-proxy进程来处理网络代理和负载均衡。

下面详细的介绍一下控制平面和工作节点。

这块大家要仔细的看，基本上Kubernetes就是围绕这两个概念展开的，第一遍看不懂，就看第二遍。

控制平面组件

Kube-APIServer

Kube-APIServer 是 Kubernetes 控制平面的核心组件，负责处理所有的 REST 操作，暴露 Kubernetes API。它是整个集群的前端，所有的控制请求都要经过它。

功能：

1. 验证和授权：Kube-APIServer 负责验证用户的身份，并根据配置的访问控制策略进行授权，确保只有合法的请求才能对集群进行操作。
2. 集群状态管理：APIServer 是集群的状态中心，所有的集群状态信息都通过它来访问和更新。
3. 通信枢纽：Kube-APIServer 是其他控制平面组件和工作节点与集群进行通信的桥梁。所有的组件和节点都通过它来获取和更新集群状态。

当用户或其他组件向 Kube-APIServer 发送请求时，APIServer 首先进行身份验证和授权检查，然后对请求的数据进行验证和处理。处理完成后，APIServer 会将数据存储到 etcd 中，同时通知其他组件进行相应的操作。

Etcd

Etcd 是一个分布式键值存储，用于存储 Kubernetes 集群的所有数据。它是 Kubernetes 集群的源数据存储系统，所有的配置信息、状态信息都存储在 etcd 中。

功能：

1. 数据存储：Etcd 负责存储所有的集群状态数据，包括 Pod、Service、ConfigMap、Secret 等。
2. 数据可靠性：Etcd 通过分布式架构保证数据的高可用性和一致性，确保集群状态数据在发生故障时仍能可靠存储。
3. 数据访问：Etcd 提供了高效的键值对存储和访问接口，支持高频率的读写操作，满足 Kubernetes 对集群状态数据的高频访问需求。

Kube-APIServer 通过 etcd API 进行数据的读写操作。当集群状态发生变化时，APIServer 会将新的状态数据写入 etcd，同时其他组件可以监听 etcd 的变化，从而进行相应的处理。

Kube-Scheduler

Kube-Scheduler 是 Kubernetes 的调度组件，负责将新创建的 Pod 调度到合适的工作节点上。它根据预设的调度策略和节点状态，选择最合适的节点来运行 Pod。

功能：

1. 资源调度：Kube-Scheduler 根据节点的资源使用情况和 Pod 的资源需求，选择合适的节点来运行 Pod。
2. 策略配置：Kube-Scheduler 支持多种调度策略，包括资源优先、亲和性、反亲和性等，用户可以根据需求自定义调度策略。
3. 负载均衡：通过合理的调度策略，Kube-Scheduler 能够有效地分配负载，避免节点过载，确保集群的高效运行。

Kube-Scheduler 通过监听 Kube-APIServer 上的调度请求，获取需要调度的 Pod 列表。然后，它根据预设的调度策略和节点的状态，选择最合适的节点，并将调度结果写回 APIServer，最终由相应的节点来运行 Pod。

Kube-Controller-Manager

Kube-Controller-Manager 是 Kubernetes 控制平面的控制管理组件，负责管理集群的各种控制器。这些控制器是用于处理集群状态变化的后台进程。

功能：

1. 控制器管理：包括 Node Controller、Replication Controller、Endpoint Controller、Namespace Controller 等，这些控制器分别负责节点管理、副本管理、服务发现、命名空间管理等功能。
2. 自动化操作：控制器通过监听集群状态变化，自动执行相应的操作，如副本调整、故障节点隔离、服务更新等。
3. 一致性保证：通过控制器的自动化操作，Kube-Controller-Manager 保证了集群状态的一致性和可靠性。

Kube-Controller-Manager 通过监听 Kube-APIServer 的事件，获取集群状态变化的信息。根据不同的控制器，它会执行相应的操作，如创建或删除 Pod、副本调整、节点故障处理等，并将结果写回 APIServer，从而更新集群状态。

Cloud-Controller-Manager

Cloud-Controller-Manager 是 Kubernetes 控制平面的云服务管理组件，用于将 Kubernetes 与底层的云服务集成。它抽象了底层云平台的差异，使得 Kubernetes 可以在不同的云平台上运行。

功能：

1. 云资源管理：包括节点管理、负载均衡、存储管理等功能，支持将 Kubernetes 与各种云服务（如 AWS、GCP、Azure）集成。
2. 多云支持：通过抽象底层云平台的差异，Cloud-Controller-Manager 使得 Kubernetes 可以在多种云平台上无缝运行。
3. 自动化操作：通过自动化管理云资源，Cloud-Controller-Manager 提高了 Kubernetes 集群的可用性和灵活性。

Cloud-Controller-Manager 通过调用底层云平台的 API，执行相应的操作，如节点创建、负载均衡配置、存储卷管理等。它通过监听 Kube-APIServer 的事件，获取需要执行的操作，然后调用云平台的 API 来完成相应的操作，并将结果写回 APIServer，从而更新集群状态。

工作节点组件

Kubelet

Kubelet 是运行在每个工作节点上的主要代理进程，负责管理节点上的 Pod 和容器。它通过与 Kube-APIServer 交互，确保节点上容器的正确运行。

功能：

1. Pod 管理：Kubelet 负责启动和停止节点上的 Pod，并监控它们的状态，确保每个 Pod 按照预期运行。
2. 状态报告：Kubelet 定期向 Kube-APIServer 报告节点和 Pod 的状态，包括资源使用情况、健康状态等。
3. 配置管理：Kubelet 根据从 Kube-APIServer 获取的配置信息，配置和管理节点上的容器运行环境。

Kubelet 通过监听 Kube-APIServer 的调度信息，获取需要在本节点上运行的 Pod 列表。它根据 Pod 的配置文件，调用容器运行时（如 Docker、containerd）来启动和管理容器。同时，Kubelet 会定期向 Kube-APIServer 发送心跳信号和状态报告，确保控制平面能够及时了解节点和 Pod 的运行状况。

Kube-Proxy

Kube-Proxy 是 Kubernetes 中的网络代理服务，运行在每个工作节点上，负责维护网络规则，管理 Pod 间的网络通信和负载均衡。

功能：

1. 服务发现：Kube-Proxy 负责维护节点上的网络规则，确保服务 IP 和端口能够正确映射到相应的 Pod 上。
2. 负载均衡：Kube-Proxy 通过 IPTables 或 IPVS 实现服务的负载均衡，将请求分发到后端的多个 Pod 上。
3. 网络路由：Kube-Proxy 处理网络流量，确保节点内外的通信能够正确路由到目标 Pod。

Kube-Proxy 通过监听 Kube-APIServer 获取服务和端点的变化信息，然后根据这些信息动态更新节点上的网络规则。它使用 IPTables 或 IPVS 来实现网络流量的转发和负载均衡，确保请求能够正确分发到相应的 Pod 上。

容器运行时

容器运行时（Container Runtime）是 Kubernetes 中用于运行和管理容器的组件，常见的容器运行时有 Docker、containerd、CRI-O 等。

功能：

1. 容器管理：容器运行时负责启动、停止和监控容器的运行状态。
2. 资源隔离：容器运行时通过 cgroup、namespace 等机制实现容器的资源隔离和限制。
3. 镜像管理：容器运行时负责从镜像仓库拉取容器镜像，并在节点上进行存储和管理。

Kubelet 通过 CRI（Container Runtime Interface）与容器运行时进行交互，向其发送启动和停止容器的指令。容器运行时根据这些指令，调用底层操作系统的容器技术（如 cgroup、namespace）来管理容器的生命周期和资源使用。同时，容器运行时还负责从镜像仓库拉取和管理容器镜像，确保容器能够按需启动。

Node Local Controller

Node Local Controller 是 Kubernetes 中的一种节点本地控制器，负责在每个节点上执行一些特定的控制任务，如本地存储管理、节点健康检查等。

功能：

1. 本地存储管理：Node Local Controller 负责管理节点上的本地存储资源，如临时存储卷、持久化存储卷等。
2. 节点健康检查：通过定期检查节点的运行状态，Node Local Controller 能够及时发现并报告节点的健康问题。
3. 资源分配：根据节点的资源使用情况，Node Local Controller 可以调整资源分配策略，确保节点上的 Pod 能够高效运行。

Node Local Controller 运行在每个工作节点上，通过监听 Kubelet 和 Kube-APIServer 的事件，获取节点的状态信息。根据这些信息，它执行相应的控制操作，如调整存储卷、进行健康检查等，并将结果报告给 Kube-APIServer，从而更新集群的状态。

Kubernetes 网络模型

Pod 和 Service 的网络通信

Kubernetes 的网络模型基于 Pod 和 Service 的通信，通过统一的 IP 地址和端口分配，确保集群内的各个组件能够无缝通信。

Pod 网络

1. 每个 Pod 一个 IP：每个 Pod 都有一个唯一的 IP 地址，这个 IP 地址在整个集群内都是可达的。
2. Pod 间通信：Pod 可以直接通过 IP 地址互相通信，无需进行 NAT（网络地址转换）。
3. Pod 网络插件：Kubernetes 支持多种网络插件（如 Flannel、Calico、Weave），它们通过 CNI（Container Network Interface）接口与 Kubernetes 集成，提供灵活的网络实现。

Service 网络

1. 虚拟 IP：Service 在 Kubernetes 中有一个虚拟 IP 地址（Cluster IP），用于暴露一组 Pod。
2. 服务发现：Service 的 IP 地址和端口通过 DNS 解析，使得客户端可以通过服务名访问相应的服务。
3. 负载均衡：Service 自动将请求分发到后端的多个 Pod 上，实现负载均衡。

网络策略（Network Policy）

网络策略是 Kubernetes 中用于定义 Pod 之间通信规则的机制，通过配置网络策略，可以控制哪些 Pod 可以互相通信。

功能：

1. 访问控制：通过网络策略，可以定义允许和拒绝的通信规则，控制 Pod 之间的访问。
2. 隔离策略：网络策略可以用于隔离不同的应用和环境，确保敏感数据和服务的安全性。
3. 动态更新：网络策略可以动态更新，根据业务需求调整通信规则，提供灵活的网络控制。

网络策略是基于标签的规则，通过定义一组规则，指定允许或拒绝哪些 Pod 的通信。网络策略由网络插件实现，通过监听和解析网络策略的配置，动态更新网络规则，确保 Pod 间的通信符合预期。

Kubernetes 存储架构

Kubernetes 提供了多种存储解决方案，以满足不同应用场景下的数据持久化需求。存储在 Kubernetes 中主要通过卷（Volume）和持久化卷（Persistent Volume, PV）来实现。

卷（Volume）

卷是与 Pod 生命周期相关联的存储单元，用于在 Pod 内部或多个容器之间共享数据。Kubernetes 支持多种类型的卷，每种卷类型具有不同的特性和用途。

类型

1. emptyDir：一个空目录，随着 Pod 的创建而创建，Pod 被删除时也会被删除。适用于临时数据存储。
2. hostPath：挂载宿主机上的目录到 Pod 内部，适用于需要访问宿主机文件系统的场景。
3. nfs：网络文件系统，允许多个 Pod 共享同一个存储资源。
4. configMap 和 secret：用于将配置信息和敏感数据注入到 Pod 中。
5. persistentVolumeClaim：用于绑定持久化卷（PV），实现数据持久化。

在 Pod 的定义中，可以通过 volumes 字段指定所需的卷，并通过 volumeMounts 字段将卷挂载到容器的文件系统中。例如：

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
    volumeMounts:
    - mountPath: /usr/share/nginx/html
      name: my-volume
  volumes:
  - name: my-volume
    emptyDir: {}

持久化卷（Persistent Volume, PV）

持久化卷是集群级别的存储资源，独立于 Pod 生命周期存在。PV 提供了一种抽象，用于管理不同类型的底层存储（如 NFS、iSCSI、云存储等）。

特性

1. 持久性：PV 的生命周期独立于 Pod，确保数据在 Pod 重启或迁移后仍然存在。
2. 动态供应：Kubernetes 支持动态创建 PV，根据 PVC（Persistent Volume Claim）的请求自动分配存储资源。
3. 多种存储后端：支持本地存储、NFS、Ceph、GlusterFS 以及各大云供应商的存储服务（如 AWS EBS、GCE PD 等）。

PV 的使用涉及两部分：持久化卷（PV）的定义和持久化卷声明（PVC）。PV 由管理员创建和管理，而 PVC 由用户创建，用于请求和使用存储资源。

示例：创建 PV

apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  nfs:
    path: /path/to/nfs
    server: nfs-server.example.com

示例：创建 PVC

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

在 Pod 中使用 PVC

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
    volumeMounts:
    - mountPath: /usr/share/nginx/html
      name: my-storage
  volumes:
  - name: my-storage
    persistentVolumeClaim:
      claimName: my-pvc

存储类（StorageClass）

存储类是用于动态供应 PV 的机制，提供了一种抽象来定义存储资源的不同特性和配置。通过 StorageClass，用户可以根据需求自动创建 PV。

特性

1. 动态供应：根据 PVC 的请求动态创建 PV，简化了存储资源的管理。
2. 参数化配置：StorageClass 可以包含参数，用于定义存储资源的具体配置，如存储类型、性能等级等。
3. 支持多种后端：可以为不同的存储后端定义不同的 StorageClass，如 SSD、HDD、NFS 等。

管理员可以创建多个 StorageClass，为用户提供不同的存储选项。用户在创建 PVC 时，可以指定使用哪种 StorageClass。

示例：创建 StorageClass

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: fast
provisioner: kubernetes.io/aws-ebs
parameters:
  type: io1
  iopsPerGB: "10"
  fsType: ext4

示例：使用 StorageClass 创建 PVC

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-fast-pvc
spec:
  storageClassName: fast
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

Kubernetes 安全机制

Kubernetes 提供了多层次的安全机制，涵盖身份认证、授权、网络安全和密钥管理等方面，确保集群和应用的安全性。

身份认证

身份认证是验证用户或组件身份的过程，确保只有合法的用户和组件才能访问 Kubernetes API。Kubernetes 支持多种认证机制，包括客户端证书、静态 Token、服务账户和外部认证系统。

机制

1. 客户端证书：通过 X.509 证书对用户进行认证，通常用于集群管理员。
2. 静态 Token：使用预定义的 Token 进行认证，适用于简单的测试和开发环境。
3. 服务账户：用于 Pod 内部组件的认证，服务账户由 Kubernetes 自动创建和管理。
4. 外部认证：集成外部身份提供商（如 OAuth、LDAP），通过 webhook 或 OpenID Connect 进行认证。

使用客户端证书进行认证

创建证书和密钥：

openssl genrsa -out user.key 2048
openssl req -new -key user.key -out user.csr
openssl x509 -req -in user.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out user.crt -days 365

配置 kubeconfig 文件：

apiVersion: v1
kind: Config
users:
- name: my-user
  user:
    client-certificate: /path/to/user.crt
    client-key: /path/to/user.key

授权

授权是控制用户或组件对 Kubernetes 资源的访问权限。Kubernetes 提供了多种授权机制，包括基于角色的访问控制（RBAC）、属性基础访问控制（ABAC）和节点授权等。

机制

1. RBAC：通过角色和角色绑定控制用户和组件对资源的访问权限，适用于大多数使用场景。
2. ABAC：基于属性的访问控制，通过策略文件定义复杂的访问规则，适用于特定的安全需求。
3. 节点授权：用于控制节点组件（如 Kubelet）对 API 资源的访问权限，确保节点只能访问其所需的资源。

使用 RBAC 进行授权

创建角色和角色绑定：

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: my-user
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

网络安全

网络安全是确保集群内外的网络通信安全，防止未经授权的访问和攻击。Kubernetes 提供了多种网络安全机制，包括网络策略、网络隔离和加密通信等。

机制

1. 网络策略：通过定义 Pod 之间的通信规则，控制网络流量的访问权限。
2. 网络隔离：将不同的应用和环境隔离在不同的命名空间中，减少攻击面。
3. 加密通信：通过 TLS 加密集群内外的通信，确保数据传输的安全性。

使用网络策略控制通信

定义网络策略：

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-nginx
  namespace: default
spec:
 

 podSelector:
    matchLabels:
      app: nginx
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 80

密钥管理

密钥管理是保护敏感数据（如密码、令牌、证书等）的重要机制。Kubernetes 提供了 Secret 对象，用于安全地存储和管理敏感数据。

使用

1. 创建 Secret：通过 YAML 文件或命令行工具创建 Secret 对象。
2. 挂载 Secret：将 Secret 挂载到 Pod 的环境变量或文件系统中，供应用使用。
3. 密钥加密：在 etcd 存储中加密 Secret 数据，增加数据的安全性。

创建和使用 Secret

创建 Secret：

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
data:
  username: YWRtaW4=  # base64 编码的 'admin'
  password: MWYyZDFlMmU2N2Rm  # base64 编码的 '1f2d1e2e67df'

在 Pod 中使用 Secret：

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
    env:
    - name: USERNAME
      valueFrom:
        secretKeyRef:
          name: my-secret
          key: username
    - name: PASSWORD
      valueFrom:
        secretKeyRef:
          name: my-secret
          key: password

Kubernetes 调度器（Scheduler）

Kubernetes 调度器是负责将 Pod 分配到集群中合适的节点上的组件。调度器在 Pod 创建时决定其运行的节点，并根据多种因素优化调度决策。

调度策略

调度策略是调度器在选择节点时遵循的一系列规则和约束。通过配置调度策略，Kubernetes 可以实现高效的资源利用和应用的高可用性。

主要策略

1. 资源请求和限制：根据 Pod 请求的 CPU 和内存资源，选择满足资源需求的节点。
2. 节点选择器（Node Selector）：根据 Pod 的节点选择器标签，将 Pod 分配到特定的节点。
3. 亲和性和反亲和性（Affinity/Anti-Affinity）：定义 Pod 与其他 Pod 之间的亲和或反亲和关系，影响 Pod 的调度决策。
4. 污点和容忍度（Taints and Tolerations）：通过污点阻止 Pod 调度到特定节点，容忍度允许 Pod 忽略污点。

使用节点选择器调度 Pod

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
  nodeSelector:
    disktype: ssd

使用亲和性和反亲和性调度 Pod

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: disktype
            operator: In
            values:
            - ssd
    podAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchExpressions:
          - key: app
            operator: In
            values:
            - frontend
        topologyKey: "kubernetes.io/hostname"
    podAntiAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        podAffinityTerm:
          labelSelector:
            matchExpressions:
            - key: app
              operator: In
              values:
              - backend
          topologyKey: "kubernetes.io/hostname"

Kubernetes 应用管理

Kubernetes 提供了多种机制来管理和部署应用，包括 Deployment、StatefulSet、DaemonSet 和 Job 等。这些机制帮助开发和运维人员高效地管理容器化应用。

Deployment

Deployment 是用于管理无状态应用的控制器，通过声明式配置和滚动更新，确保应用的高可用性和稳定性。

功能

1. 声明式更新：通过定义目标状态，自动实现应用的更新和回滚。
2. 滚动更新：逐步替换旧版本的 Pod，确保应用在更新过程中始终可用。
3. 回滚机制：在更新失败时，可以快速回滚到之前的稳定版本。

创建 Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

StatefulSet

StatefulSet 是用于管理有状态应用的控制器，确保 Pod 有稳定的网络标识和存储，适用于数据库、缓存等有状态服务。

功能

1. 稳定的网络标识：每个 Pod 有唯一的名称和 DNS 记录，确保网络标识的稳定性。
2. 有序部署和更新：按照顺序部署和更新 Pod，确保有状态应用的正确初始化和更新。
3. 持久化存储：每个 Pod 绑定独立的持久化存储，确保数据的持久性。

创建 StatefulSet

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "nginx"
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
          name: web
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 1Gi

DaemonSet

DaemonSet 是用于在每个节点上运行一个 Pod 的控制器，适用于日志收集、监控等全节点运行的应用。

功能

1. 节点级应用：确保每个节点上都运行一个 Pod，实现全节点的应用部署。
2. 自动扩展：当有新节点加入集群时，自动在新节点上部署相应的 Pod。
3. 资源管理：通过 DaemonSet 管理系统级的资源和服务。

创建 DaemonSet

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd
  labels:
    app: fluentd
spec:
  selector:
    matchLabels:
      name: fluentd
  template:
    metadata:
      labels:
        name: fluentd
    spec:
      containers:
      - name: fluentd
        image: fluentd:v1.12
        resources:
          limits:
            memory: 200Mi
            cpu: 0.5

Job 和 CronJob

Job 和 CronJob 是用于批处理任务的控制器，Job 负责一次性任务的执行，而 CronJob 则用于定时任务的管理。

功能

1. 一次性任务：Job 确保任务在完成前至少运行一次，适用于一次性计算任务。
2. 定时任务：CronJob 按照预定的时间表运行任务，适用于定期执行的任务。
3. 任务并行：支持任务的并行执行，提升批处理任务的效率。

创建 Job

apiVersion: batch/v1
kind: Job
metadata:
  name: pi
spec:
  template:
    metadata:
      name: pi
    spec:
      containers:
      - name: pi
        image: perl
        command: ["perl",  "-Mbignum=bpi", "-wle", "print bpi(2000)"]
      restartPolicy: Never
  backoffLimit: 4

创建 CronJob

apiVersion: batch/v1beta1
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "*/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello
            image: busybox


            args:
            - /bin/sh
            - -c
            - date; echo Hello from the Kubernetes cluster
          restartPolicy: OnFailure

写在最后

Kubernetes 架构涵盖了从基础组件到高级功能的方方面面，为应用的容器化部署、管理和运维提供了强大的工具和机制。通过详细了解和掌握这些组件和机制，可以帮助开发和运维人员更高效地管理和优化 Kubernetes 集群，确保应用的高可用性、可扩展性和安全性。在实际应用中，结合具体业务需求和环境，灵活运用 Kubernetes 提供的各种功能和特性，才能充分发挥其优势，实现持续集成和持续交付（CI/CD）的目标。