MK
摩柯社区 - 一个极简的技术知识社区
AI 面试
Kubernetes 编排微服务集群
2021-12-155.6k 阅读

Kubernetes 编排微服务集群

一、Kubernetes 基础概念

1.1 Pod

Pod 是 Kubernetes 中最小的可部署和可管理的计算单元。它可以包含一个或多个紧密相关的容器。这些容器共享网络命名空间、存储卷等资源，并且通常会紧密协作以完成特定的功能。例如，一个 Web 应用可能有一个应用容器和一个日志收集容器，它们被打包在同一个 Pod 中。

Pod 的设计理念是将这些紧密耦合的容器作为一个整体进行调度和管理。当 Pod 被创建时，Kubernetes 会为其分配一个唯一的 IP 地址，Pod 内的容器可以通过 localhost 相互通信。同时，Pod 作为一个原子单元，要么所有容器都成功运行，要么都失败。

以下是一个简单的 Pod 定义示例（使用 YAML 格式）：

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx:1.14.2
    ports:
    - containerPort: 80

在这个示例中，我们定义了一个名为 my - pod 的 Pod，它包含一个使用 nginx:1.14.2 镜像的容器，并将容器的 80 端口暴露出来。

1.2 标签（Label）与选择器（Selector）

标签是附加到 Kubernetes 对象（如 Pod、Service 等）上的键值对，用于对对象进行标识和分类。例如，我们可以为一组用于生产环境的 Pod 添加 environment: production 标签，为开发环境的 Pod 添加 environment: development 标签。

选择器则是用于筛选具有特定标签的对象的工具。有两种类型的选择器：基于等式的选择器和基于集合的选择器。

基于等式的选择器示例：environment = production，它会选择所有标签中 environment 等于 production 的对象。

基于集合的选择器示例：environment in (production, staging)，它会选择标签中 environment 为 production 或 staging 的对象。

标签和选择器在 Kubernetes 中非常重要，它们使得我们可以灵活地对资源进行管理、部署和扩展。例如，通过选择器可以轻松地将一组 Pod 与一个 Service 关联起来，实现负载均衡。

1.3 服务（Service）

Service 是 Kubernetes 中用于暴露 Pod 的抽象层。它为一组具有相同功能的 Pod 提供了一个稳定的网络端点，使得其他 Pod 或外部客户端可以通过这个端点访问这些 Pod，而无需关心 Pod 的实际 IP 地址和数量变化。

Kubernetes 中有几种类型的 Service：

  1. ClusterIP：默认类型，它为 Service 分配一个集群内部的 IP 地址，只能在集群内部访问。常用于内部服务之间的通信。
  2. NodePort：在每个 Node 上开放一个特定端口，通过 <NodeIP>:<NodePort> 可以从集群外部访问 Service。这种方式适合用于开发和测试环境，或者当没有负载均衡器可用时。
  3. LoadBalancer：使用云提供商的负载均衡器将 Service 暴露到外部。适用于生产环境，能够自动处理流量分发和负载均衡。

以下是一个 ClusterIP 类型 Service 的定义示例：

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my - app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP

在这个示例中，my - service 会选择所有带有 app: my - app 标签的 Pod，并将这些 Pod 的 80 端口映射到 Service 的 80 端口，通过 ClusterIP 方式在集群内部提供服务。

二、Kubernetes 集群搭建

2.1 环境准备

在搭建 Kubernetes 集群之前，需要准备以下环境：

  1. 操作系统：推荐使用 Linux 系统，如 Ubuntu、CentOS 等。本文以 Ubuntu 20.04 为例。
  2. 硬件资源：至少需要一台主控节点（Master）和一台工作节点（Worker）。每个节点建议至少 2 核 CPU 和 2GB 内存。
  3. 网络配置：确保节点之间网络互通，并且每个节点都有固定的 IP 地址。

2.2 安装 Docker

Docker 是 Kubernetes 中容器运行时的常用选择。在每个节点上安装 Docker：

  1. 更新系统软件包：
sudo apt update
sudo apt upgrade
  1. 安装 Docker 依赖包：
sudo apt install apt - transport - https ca - certificates curl software - properties - common
  1. 添加 Docker 官方 GPG 密钥：
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt - key add -
  1. 添加 Docker 软件源：
sudo add - apt - repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
  1. 安装 Docker：
sudo apt update
sudo apt install docker - ce docker - ce - cli containerd.io
  1. 启动并设置 Docker 开机自启：
sudo systemctl start docker
sudo systemctl enable docker

2.3 安装 Kubernetes 组件

  1. 添加 Kubernetes 软件源：
curl -s https://packages.cloud.google.com/apt/doc/apt - key.gpg | sudo apt - key add -
sudo apt - get install - y apt - transport - https
echo "deb https://apt.kubernetes.io/ kubernetes - xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
  1. 安装 Kubernetes 组件（kubeadm、kubelet、kubectl）：
sudo apt update
sudo apt install -y kubeadm kubelet kubectl
  1. 锁定 Kubernetes 组件版本，防止自动更新：
sudo apt - mark hold kubeadm kubelet kubectl

2.4 初始化主控节点（Master）

在主控节点上执行以下命令初始化 Kubernetes 集群：

sudo kubeadm init --pod - network - cidr=10.244.0.0/16

--pod - network - cidr 参数指定了 Pod 网络的地址范围，这里使用 10.244.0.0/16 作为示例。

初始化成功后，会输出一些后续操作的提示信息，例如如何配置 kubectl 以及如何将工作节点加入集群。按照提示操作：

  1. 配置 kubectl：
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
  1. 记录下 kubeadm join 命令，用于将工作节点加入集群。

2.5 安装网络插件

Kubernetes 本身不提供网络实现，需要安装第三方网络插件来实现 Pod 之间的通信。常用的网络插件有 Flannel、Calico 等。这里以 Flannel 为例：

  1. 下载 Flannel 配置文件：
wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube - flannel.yml
  1. 应用配置文件：
kubectl apply -f kube - flannel.yml

2.6 添加工作节点（Worker）

在每个工作节点上执行之前记录的 kubeadm join 命令，例如：

sudo kubeadm join 192.168.1.100:6443 --token <token> --discovery - token - ca - cert - hash sha256:<hash>

其中，192.168.1.100 是主控节点的 IP 地址，<token> 和 <hash> 是初始化主控节点时生成的信息。

三、在 Kubernetes 上部署微服务

3.1 微服务镜像制作

假设我们有一个简单的 Python Flask 微服务，代码如下（app.py）：

from flask import Flask

app = Flask(__name__)


@app.route('/')
def hello_world():
    return 'Hello, World!'


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

制作 Docker 镜像的步骤如下：

  1. 在项目目录下创建 Dockerfile：
FROM python:3.8 - slim

WORKDIR /app

COPY requirements.txt.
RUN pip install -r requirements.txt

COPY.

EXPOSE 5000

CMD ["python", "app.py"]
  1. 构建镜像：
docker build -t my - flask - app:v1.0.0.

这里 -t 参数指定了镜像的标签，格式为 镜像名称:版本号。

3.2 部署微服务到 Kubernetes

  1. 创建 Deployment： Deployment 是 Kubernetes 中用于管理 Pod 副本数量和滚动升级的资源对象。创建一个 deployment.yml 文件：
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my - flask - deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my - flask - app
  template:
    metadata:
      labels:
        app: my - flask - app
    spec:
      containers:
      - name: my - flask - container
        image: my - flask - app:v1.0.0
        ports:
        - containerPort: 5000

在这个示例中，我们定义了一个名为 my - flask - deployment 的 Deployment，它会创建 3 个副本的 Pod，每个 Pod 运行 my - flask - app:v1.0.0 镜像，并将容器的 5000 端口暴露出来。

应用 Deployment：

kubectl apply -f deployment.yml
  1. 创建 Service： 为了让外部能够访问到我们的微服务，需要创建一个 Service。创建 service.yml 文件：
apiVersion: v1
kind: Service
metadata:
  name: my - flask - service
spec:
  selector:
    app: my - flask - app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 5000
  type: NodePort

这里创建了一个 NodePort 类型的 Service，将外部的 80 端口映射到 Pod 的 5000 端口。

应用 Service：

kubectl apply -f service.yml

通过以上步骤，我们就将一个简单的微服务部署到了 Kubernetes 集群上，并通过 Service 使其可以从外部访问。

四、Kubernetes 微服务管理与运维

4.1 监控与日志

  1. 监控： Kubernetes 本身提供了一些基本的监控指标，如 Pod 的 CPU 和内存使用情况。可以通过 kubectl top 命令查看：
kubectl top pods

为了更全面的监控，通常会集成 Prometheus 和 Grafana。Prometheus 用于收集和存储监控数据，Grafana 用于可视化展示。

安装 Prometheus Operator 可以方便地部署 Prometheus 和相关组件。例如，使用 Helm 安装：

helm repo add prometheus - community https://prometheus - community.github.io/helm - charts
helm install prometheus - community/prometheus - operator
  1. 日志： 容器日志是排查问题的重要依据。可以通过 kubectl logs 命令查看 Pod 内容器的日志：
kubectl logs <pod - name>

如果 Pod 内有多个容器，可以通过 -c <container - name> 参数指定容器。

对于大规模集群的日志管理，通常会使用 Elasticsearch、Fluentd 和 Kibana（EFK 堆栈）。Fluentd 用于收集和转发容器日志到 Elasticsearch，Kibana 用于可视化查询和分析日志。

4.2 滚动升级与回滚

  1. 滚动升级： 假设我们有一个新的微服务镜像版本 my - flask - app:v2.0.0，要进行滚动升级，可以更新 Deployment 的镜像版本：
kubectl set image deployment/my - flask - deployment my - flask - container=my - flask - app:v2.0.0

Kubernetes 会逐步替换旧版本的 Pod 为新版本，在升级过程中，可以通过 kubectl rollout status 命令查看升级状态：

kubectl rollout status deployment/my - flask - deployment
  1. 回滚： 如果升级过程中出现问题，需要回滚到上一个版本，可以使用 kubectl rollout undo 命令：
kubectl rollout undo deployment/my - flask - deployment

Kubernetes 会将 Deployment 恢复到上一个稳定版本的状态。

4.3 资源管理

  1. 资源请求与限制： 在 Deployment 中，可以为容器设置资源请求（requests）和限制（limits）。例如：
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my - flask - deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my - flask - app
  template:
    metadata:
      labels:
        app: my - flask - app
    spec:
      containers:
      - name: my - flask - container
        image: my - flask - app:v1.0.0
        ports:
        - containerPort: 5000
        resources:
          requests:
            cpu: "200m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "1Gi"

这里为容器设置了 CPU 请求为 200 毫核（200m），内存请求为 512MiB；CPU 限制为 500 毫核，内存限制为 1GiB。通过合理设置资源请求和限制，可以避免容器过度占用资源导致集群性能问题。 2. 命名空间（Namespace）： 命名空间是 Kubernetes 中用于隔离资源的概念。可以将不同的微服务部署到不同的命名空间中，实现资源的逻辑分组和隔离。

创建命名空间：

kubectl create namespace my - namespace

在创建资源（如 Deployment、Service 等）时，可以通过 --namespace 参数指定命名空间：

kubectl apply -f deployment.yml --namespace=my - namespace

五、Kubernetes 高级特性

5.1 自动伸缩（Horizontal Pod Autoscaling，HPA）

HPA 允许根据 Pod 的 CPU 利用率或其他自定义指标自动调整 Pod 的副本数量。例如，根据 CPU 利用率自动伸缩：

  1. 确保 Deployment 已经设置了资源请求和限制，如上述示例。
  2. 创建 HPA：
kubectl autoscale deployment my - flask - deployment --cpu - percent=50 --min=1 --max=10

这个命令会创建一个 HPA，目标是将 my - flask - deployment 的 CPU 利用率维持在 50% 左右，最小副本数为 1，最大副本数为 10。当集群负载增加，CPU 利用率超过 50% 时，Kubernetes 会自动增加 Pod 副本；当负载降低时，会自动减少副本。

5.2 持久化存储

在微服务应用中，有时需要持久化存储数据，如数据库文件、配置文件等。Kubernetes 提供了多种持久化存储方案，如 PersistentVolume（PV）和 PersistentVolumeClaim（PVC）。

  1. PV： PV 是集群中由管理员提供的存储资源。例如，创建一个基于本地目录的 PV：
apiVersion: v1
kind: PersistentVolume
metadata:
  name: my - pv
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /data/my - pv

这里创建了一个容量为 1Gi 的 PV，使用 ReadWriteOnce 访问模式，表示可以被单个节点以读写方式挂载，存储路径为 /data/my - pv。

  1. PVC： PVC 是用户对存储资源的请求。例如：
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my - pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi

这里创建了一个 PVC，请求 500Mi 的存储资源，使用 ReadWriteOnce 访问模式。Kubernetes 会自动将符合条件的 PV 绑定到这个 PVC 上。

在 Deployment 中使用 PVC：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my - flask - deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my - flask - app
  template:
    metadata:
      labels:
        app: my - flask - app
    spec:
      containers:
      - name: my - flask - container
        image: my - flask - app:v1.0.0
        ports:
        - containerPort: 5000
        volumeMounts:
        - name: my - volume
          mountPath: /app/data
      volumes:
      - name: my - volume
        persistentVolumeClaim:
          claimName: my - pvc

在这个示例中，将 PVC my - pvc 挂载到容器的 /app/data 目录，实现数据的持久化存储。

5.3 服务网格（Service Mesh）

服务网格是一种用于管理和控制微服务之间通信的基础设施层。Istio 是一个流行的服务网格解决方案，它可以提供流量管理、安全、监控等功能。

  1. 安装 Istio： 可以使用 Istio 安装工具 istioctl 进行安装。例如，下载并安装最新版本：
curl -L https://istio.io/downloadIstio | sh -
cd istio - 1.11.0
export PATH=$PWD/bin:$PATH
istioctl install --set profile=demo
  1. 使用 Istio： 将微服务部署到 Istio 服务网格中，需要将 Pod 注入 Istio 代理（Sidecar）。例如，使用 istioctl 注入代理：
kubectl apply -f <(istioctl kube - inject - f deployment.yml)

注入代理后，Istio 可以对微服务之间的流量进行管理，如设置路由规则、限流、熔断等。例如，设置流量路由规则：

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: my - flask - service - vs
spec:
  hosts:
  - my - flask - service
  http:
  - route:
    - destination:
        host: my - flask - service
        subset: v1
      weight: 90
    - destination:
        host: my - flask - service
        subset: v2
      weight: 10

这个规则将 90% 的流量路由到 my - flask - service 的 v1 版本，10% 的流量路由到 v2 版本，实现灰度发布等功能。

通过以上对 Kubernetes 编排微服务集群的各个方面的介绍，包括基础概念、集群搭建、微服务部署、管理运维以及高级特性，相信读者对如何使用 Kubernetes 来构建和管理微服务集群有了较为全面深入的了解。在实际应用中，可以根据具体的业务需求和场景，灵活运用这些知识，打造高效、可靠的微服务架构。