GitOps 实操手册 3：示例应用的部署和解析

内容简介

本实验手册系列包含七个主题，涵盖了从应用容器化到 GitOps 工作流的实现与高级特性。通过这些实验手册，您将学习到如何构建、部署和管理应用，以及如何在 Kubernetes 集群上实现高效的持续交付流程。

以下是实验手册的七个章节：

1. 应用程序容器化实验手册：学习如何将应用程序容器化，并为主流编程语言构建镜像。同时，了解如何缩减镜像体积和使用 GitHub Actions 自动构建镜像。
2. 单节点 Kubernetes 集群部署实验手册：使用 kind 在本地部署单节点 Kubernetes 集群，安装基础服务，并熟悉 Kubernetes 的基本功能，如运行 Pod、调度工作负载、服务发布和自动扩缩容。
3. 示例应用的部署和解析实验手册：深入了解示例应用的各个组件，学习如何在 Kubernetes 集群上部署、运行和管理这些组件，实现服务调用、应用配置和扩缩容等功能。
4. 使用 Helm 定义应用实验手册：通过 Helm 对示例应用进行定义，以满足 GitOps 部署的需求。了解 Helm Chart 的创建和使用，以及预发布和生产环境的部署。
5. 构建 GitOps 工作流实验手册：在 Kubernetes 集群上安装 ArgoCD，并使用 ArgoCD 定义示例应用进行部署，实现基于镜像版本变化触发的 GitOps 工作流。
6. 实现 GitOps 高级发布策略实验手册：结合 ArgoCD 的高级特性，如 Argo Rollout、AnalysisTemplate 和 Argo Rollout Dashboard，实现蓝绿发布、金丝雀发布和自动渐进交付。
7. ArgoCD 高级管理特性实验手册：探讨 ArgoCD 在 GitOps 场景中的高级特性，包括使用 ApplicationSet 实现多环境部署和使用 SealedSecret 保护密钥。

通过这七个实验手册，您将全面掌握应用容器化、Kubernetes 和 GitOps 的相关知识，为应用的持续交付提供可靠和高效的解决方案。

在前两个实验手册中，您学习了如何容器化应用程序，使用Kind部署Kubernetes集群，以及实践Kubernetes的基本功能。本实验手册将基于这些知识，引导您深入了解示例应用的部署和解析过程。我们将重点关注示例应用各个组件的分析、部署、功能解析，以及如何实现服务调用、发布、配置管理和应用扩缩容。

组件分析和部署

数据库配置分析

apiVersion: v1
data:
  CreateDB.sql: |-
    CREATE TABLE text (
        id serial PRIMARY KEY,
        text VARCHAR ( 100 ) UNIQUE NOT NULL
    );
kind: ConfigMap
metadata:
  name: pg-init-script
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
  labels:
    app: database
spec:
  replicas: 1
  selector:
    matchLabels:
      app: database
  template:
    metadata:
      labels:
        app: database
    spec:
      containers:
      - name: postgres
        image: postgres
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 5432
        volumeMounts:
        - name: sqlscript
          mountPath: /docker-entrypoint-initdb.d
        env:
          - name: POSTGRES_USER
            value: "postgres"
          - name: POSTGRES_PASSWORD
            value: "postgres"
      volumes:
        - name: sqlscript
          configMap:
            name: pg-init-script
---
apiVersion: v1
kind: Service
metadata:
  name: pg-service
  labels:
    app: database
spec:
  type: ClusterIP
  selector:
    app: database
  ports:
  - port: 5432

这个 Kubernetes 清单文件定义了一个使用 Postgres 镜像的 Deployment，其中包含一个初始化脚本（在 ConfigMap 中定义）来创建一个 “text” 表。同时，它还创建了一个 ClusterIP 类型的 Service，用于在集群内部访问 Postgres 数据库。

通过这个配置，当 Postgres 容器启动时，会自动执行 ConfigMap 中的 “CreateDB.sql” 脚本来创建 “text” 表。服务 “pg-service” 则提供了一个在集群内访问该 Postgres 数据库的统一入口，其他应用可以通过该服务与数据库进行通信。这种方式使得部署和管理 Postgres 数据库变得更加简单和灵活。

1. ConfigMap:

   • apiVersion: v1: 使用 Kubernetes API 的 v1 版本。
   • kind: ConfigMap: 表示创建一个 ConfigMap 资源。
   • metadata: ConfigMap 的元数据，包括名称 “pg-init-script”。
   • data: 包含一个 SQL 脚本 “CreateDB.sql”，用于创建一个名为 “text” 的表。这个表有两个字段：一个名为 “id” 的自增主键和一个名为 “text” 的唯一非空 VARCHAR 字段。

2. Deployment:

   • apiVersion: apps/v1: 使用 Kubernetes API 的 apps/v1 版本。
   • kind: Deployment: 表示创建一个 Deployment 资源。
   • metadata: Deployment 的元数据，包括名称 “postgres” 和一个标签 “app: database”。
   • spec: Deployment 的详细规格。
     • replicas: 1: 只创建一个副本。
     • selector: 用于选择具有 “app: database” 标签的 Pods。
     • template: 定义了 Pod 的模板。
       • metadata: 指定 Pod 的标签 “app: database”。
       • spec: Pod 的详细规格。
         • containers: 容器的列表，只有一个容器 “postgres”。
           • name: postgres: 容器的名称。
           • image: postgres: 容器的镜像。
           • imagePullPolicy: IfNotPresent: 如果镜像已经存在，就不需要拉取。
           • ports: 容器暴露的端口列表，这里只有一个端口 5432。
           • volumeMounts: 挂载的卷列表，挂载名为 “sqlscript” 的卷到容器内的 “/docker-entrypoint-initdb.d” 目录。
           • env: 定义了环境变量 “POSTGRES_USER” 和 “POSTGRES_PASSWORD”，分别设置为 “postgres” 和 “postgres”。
         • volumes: 卷的列表，这里只有一个卷 “sqlscript”。
           • name: sqlscript: 卷的名称。
           • configMap: 从 ConfigMap “pg-init-script” 创建卷。

3. Service:

   • apiVersion: v1: 使用 Kubernetes API 的 v1 版本。
   • kind: Service: 表示创建一个 Service 资源。
   • metadata: Service 的元数据，包括名称 “pg-service” 和一个标签 “app: database”。
   • spec: Service 的详细规格。
     • type: ClusterIP: 使用 ClusterIP 类型的 Service。
     • selector: 选择具有 “app: database” 标签的 Pods。
     • ports: 服务暴露的端口列表，这里只有一个端口 5432。

后端服务分析

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
  labels:
    app: backend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: flask-backend
        image: chengzh/backend:latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 5000
        env:
        - name: DATABASE_URI
          value: pg-service
        - name: DATABASE_USERNAME
          value: postgres
        - name: DATABASE_PASSWORD
          value: postgres
        resources:
          requests:
            memory: "128Mi"
            cpu: "128m"
          limits:
            memory: "256Mi"
            cpu: "256m"
        readinessProbe: 
          httpGet:
            path: /healthy
            port: 5000
            scheme: HTTP
          initialDelaySeconds: 10
          failureThreshold: 5
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
        livenessProbe: 
          httpGet:
            path: /healthy
            port: 5000
            scheme: HTTP
          failureThreshold: 5
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
        startupProbe: 
          httpGet:
            path: /healthy
            port: 5000
            scheme: HTTP
          initialDelaySeconds: 10
          failureThreshold: 5
          periodSeconds: 10
          successThreshold: 1
          timeoutSeconds: 1
---
apiVersion: v1
kind: Service
metadata:
  name: backend-service
  labels:
    app: backend
spec:
  type: ClusterIP
  selector:
    app: backend
  ports:
  - port: 5000
    targetPort: 5000

这个 Kubernetes 清单文件定义了一个基于 Flask 的后端应用的 Deployment 和一个 ClusterIP 类型的 Service。部署中的容器使用了一个自定义镜像 “chengzh/backend:latest”，并暴露了 5000 端口。同时设置了环境变量以连接到前面创建的 Postgres 数据库。Service “backend-service” 则提供了一个统一的访问点，使得集群内其他服务可以与此后端应用通信。此外，还配置了探针以确保应用的正常运行和故障恢复。

1. Deployment:

   • apiVersion: apps/v1: 使用 Kubernetes API 的 apps/v1 版本。
   • kind: Deployment: 表示创建一个 Deployment 资源。
   • metadata: Deployment 的元数据，包括名称 “backend” 和一个标签 “app: backend”。
   • spec: Deployment 的详细规格。
     • replicas: 1: 只创建一个副本。
     • selector: 用于选择具有 “app: backend” 标签的 Pods。
     • template: 定义了 Pod 的模板。
       • metadata: 指定 Pod 的标签 “app: backend”。
       • spec: Pod 的详细规格。
         • containers: 容器的列表，只有一个容器 “flask-backend”。
           • name: flask-backend: 容器的名称。
           • image: chengzh/backend:latest: 容器的镜像。
           • imagePullPolicy: IfNotPresent: 如果镜像已经存在，就不需要拉取。
           • ports: 容器暴露的端口列表，这里只有一个端口 5000。
           • env: 定义了环境变量 “DATABASE_URI”、“DATABASE_USERNAME” 和 “DATABASE_PASSWORD”，用于连接到前面创建的 Postgres 数据库。
           • resources: 定义容器的资源限制和请求。
           • readinessProbe: 定义容器的就绪探针，用于检查应用是否准备好接受流量。
           • livenessProbe: 定义容器的存活探针，用于检查应用是否仍在运行。
           • startupProbe: 定义容器的启动探针，用于检查应用是否成功启动。

2. Service:

   • apiVersion: v1: 使用 Kubernetes API 的 v1 版本。
   • kind: Service: 表示创建一个 Service 资源。
   • metadata: Service 的元数据，包括名称 “backend-service” 和一个标签 “app: backend”。
   • spec: Service 的详细规格。
     • type: ClusterIP: 使用 ClusterIP 类型的 Service。
     • selector: 选择具有 “app: backend” 标签的 Pods。
     • ports: 服务暴露的端口列表，这里只有一个端口 5000，对应容器的 5000 端口。

探针配置说明：

• readinessProbe: 就绪探针

  • httpGet: 使用 HTTP GET 请求检查应用是否准备好接受流量。
  • path: 探针访问的路径，这里设置为 “/healthy”。
  • port: 探针访问的端口，这里设置为 5000。
  • initialDelaySeconds: 容器启动后多少秒开始进行探测，默认值为 0。
  • failureThreshold: 探测失败多少次后认为容器不健康，默认值为 3。
  • periodSeconds: 探测的周期，默认值为 10。
  • successThreshold: 探测成功多少次后认为容器健康，默认值为 1。
  • timeoutSeconds: 探测超时时间，默认值为 1。

• livenessProbe: 存活探针

  • 使用与就绪探针相同的设置进行存活探测。

• startupProbe: 启动探针

  • 使用与就绪探针相同的设置进行启动探测。

通过这个配置，应用在启动、运行过程中和准备好接收请求时，Kubernetes 都会根据探针的配置检查应用的状态。这有助于确保应用在出现问题时能够自动恢复，提高了应用的可用性和稳定性。

前端服务分析

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  labels:
    app: frontend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: react-frontend
        image: chengzh/frontend:latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 3000
        resources:
          requests:
            memory: "128Mi"
            cpu: "128m"
          limits:
            memory: "256Mi"
            cpu: "256m"
---
apiVersion: v1
kind: Service
metadata:
  name: frontend-service
spec:
  type: ClusterIP
  selector:
    app: frontend
  ports:
  - port: 3000
    targetPort: 3000

这个 Kubernetes 清单文件定义了一个基于 React 的前端应用的 Deployment 和一个 ClusterIP 类型的 Service。部署中的容器使用了一个自定义镜像 “chengzh/frontend:latest”，并暴露了 3000 端口。Service “frontend-service” 则提供了一个统一的访问点，使得集群内其他服务可以与此前端应用通信。

1. Deployment:

   • apiVersion: apps/v1: 使用 Kubernetes API 的 apps/v1 版本。
   • kind: Deployment: 表示创建一个 Deployment 资源。
   • metadata: Deployment 的元数据，包括名称 “frontend” 和一个标签 “app: frontend”。
   • spec: Deployment 的详细规格。
     • replicas: 1: 只创建一个副本。
     • selector: 用于选择具有 “app: frontend” 标签的 Pods。
     • template: 定义了 Pod 的模板。
       • metadata: 指定 Pod 的标签 “app: frontend”。
       • spec: Pod 的详细规格。
         • containers: 容器的列表，只有一个容器 “react-frontend”。
           • name: react-frontend: 容器的名称。
           • image: chengzh/frontend:latest: 容器的镜像。
           • imagePullPolicy: IfNotPresent: 如果镜像已经存在，就不需要拉取。
           • ports: 容器暴露的端口列表，这里只有一个端口 3000。
           • resources: 定义容器的资源限制和请求。

2. Service:

   • apiVersion: v1: 使用 Kubernetes API 的 v1 版本。
   • kind: Service: 表示创建一个 Service 资源。
   • metadata: Service 的元数据，包括名称 “frontend-service”。
   • spec: Service 的详细规格。
     • type: ClusterIP: 使用 ClusterIP 类型的 Service。
     • selector: 选择具有 “app: frontend” 标签的 Pods。
     • ports: 服务暴露的端口列表，这里只有一个端口 3000，对应容器的 3000 端口。

ingress 分析

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: frontend-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$1
spec:
  rules:
    - http:
        paths:
          - path: /?(.*)
            pathType: Prefix
            backend:
              service:
                name: frontend-service
                port:
                  number: 3000
          - path: /api/?(.*)
            pathType: Prefix
            backend:
              service:
                name: backend-service
                port:
                  number: 5000
  ingressClassName: nginx

这个 Kubernetes 清单文件定义了一个 Ingress 资源，用于配置基于 Nginx Ingress 控制器的应用路由规则。它将根路径（及其子路径）的请求路由到 “frontend-service” 服务（端口 3000），将以 “/api” 开头的请求路由到 “backend-service” 服务（端口 5000）。这为前端和后端服务提供了一个统一的访问点。

1. Ingress:

   • apiVersion: networking.k8s.io/v1: 使用 Kubernetes API 的 networking.k8s.io/v1 版本。
   • kind: Ingress: 表示创建一个 Ingress 资源。
   • metadata: Ingress 的元数据，包括名称 “frontend-ingress”。
   • annotations: Ingress 的注解，用于配置 Ingress 控制器的行为。
     • nginx.ingress.kubernetes.io/rewrite-target: /$1: 为 Nginx Ingress 控制器设置 URL 重写规则。

2. spec: Ingress 的详细规格。

   • rules: 定义 Ingress 的路由规则。
     • 第一条规则：
       • path: /?(.*): 匹配根路径及其子路径。问号表示该子组是可选的，星号表示匹配任意字符。
       • pathType: Prefix: 表示路径匹配类型为前缀匹配。
       • backend: 定义后端服务的信息。
         • service: 指定后端服务的名称和端口。
           • name: frontend-service: 指定后端服务名称为 “frontend-service”。
           • port: 指定后端服务端口号为 3000。
     • 第二条规则：
       • path: /api/?(.*): 匹配以 “/api” 开头的路径及其子路径。
       • pathType: Prefix: 表示路径匹配类型为前缀匹配。
       • backend: 定义后端服务的信息。
         • service: 指定后端服务的名称和端口。
           • name: backend-service: 指定后端服务名称为 “backend-service”。
           • port: 指定后端服务端口号为 5000。
   • ingressClassName: nginx: 指定使用名为 “nginx” 的 Ingress 类。

HPA策略分析

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: frontend
spec:
  scaleTargetRef:
    kind: Deployment
    name: frontend
    apiVersion: apps/v1
  minReplicas: 2
  maxReplicas: 2
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 80

---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: backend
spec:
  scaleTargetRef:
    kind: Deployment
    name: backend
    apiVersion: apps/v1
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 50
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 50

这个 Kubernetes 清单文件定义了两个 HorizontalPodAutoscaler（HPA）资源，用于自动伸缩前端和后端应用的 Deployment。前端应用的 HPA 配置会根据 CPU 利用率进行伸缩，最小和最大副本数均为 2。后端应用的 HPA 配置会根据 CPU 和内存利用率进行伸缩，最小副本数为 2，最大副本数为 10。这些配置将确保在负载变化时，应用能够根据需要自动调整副本数量，以提供稳定的性能和资源利用率。

1. 前端应用的 HPA 配置：

   • apiVersion: autoscaling/v2: 使用 Kubernetes API 的 autoscaling/v2 版本。
   • kind: HorizontalPodAutoscaler: 表示创建一个 HorizontalPodAutoscaler 资源。
   • metadata: HPA 的元数据，包括名称 “frontend”。
   • spec: HPA 的详细规格。
     • scaleTargetRef: 需要伸缩的目标资源的引用。
       • kind: Deployment: 目标资源类型是 Deployment。
       • name: frontend: 目标资源的名称为 “frontend”。
       • apiVersion: apps/v1: 目标资源的 API 版本为 apps/v1。
     • minReplicas: 2: 最小副本数为 2。
     • maxReplicas: 2: 最大副本数为 2。
     • metrics: 用于驱动伸缩行为的指标。
       • type: Resource: 指标类型为资源。
       • resource: 目标资源的详细信息。
         • name: cpu: 目标资源名称为 CPU。
         • target: 目标资源的使用目标。
           • type: Utilization: 目标类型为利用率。
           • averageUtilization: 80: 平均利用率目标为 80%。

2. 后端应用的 HPA 配置：

   • apiVersion: autoscaling/v2: 使用 Kubernetes API 的 autoscaling/v2 版本。
   • kind: HorizontalPodAutoscaler: 表示创建一个 HorizontalPodAutoscaler 资源。
   • metadata: HPA 的元数据，包括名称 “backend”。
   • spec: HPA 的详细规格。
     • scaleTargetRef: 需要伸缩的目标资源的引用。
       • kind: Deployment: 目标资源类型是 Deployment。
       • name: backend: 目标资源的名称为 “backend”。
       • apiVersion: apps/v1: 目标资源的 API 版本为 apps/v1。
     • minReplicas: 2: 最小副本数为 2。
     • maxReplicas: 10: 最大副本数为 10。
     • metrics: 用于驱动伸缩行为的指标。
       • 第一个指标：
         • type: Resource: 指标类型为资源。
         • resource: 目标资源的详细信息。
           • name: cpu: 目标资源名称为 CPU。
           • target: 目标资源的使用目标。
             • type: Utilization: 目标类型为利用率。
             • averageUtilization: 50: 平均利用率目标为 50%。
       • 第二个指标：
         • type: Resource: 指标类型为资源。
         • resource: 目标资源的详细信息。
           • name: memory: 目标资源名称为内存。
           • target: 目标资源的使用目标。
             • type: Utilization: 目标类型为利用率。
             • averageUtilization: 50: 平均利用率目标为 50%。

部署示例应用

kubectl create namespace example

git clone https://ghproxy.com/https://github.com/cloudzun/kubernetes-example && cd kubernetes-example

kubectl apply -f deploy -n example

检查pod是否部署到位

kubectl wait --for=condition=Ready pods --all -n example

root@node1:~# kubectl wait --for=condition=Ready pods --all -n example
pod/backend-6b55f869fd-5mnxq condition met
pod/frontend-6b5b58d5f8-97cmm condition met
pod/postgres-fbd8f9f49-n89tl condition met

检查 example 命名空间所有的资源对象是否正常

kubectl get all -n example

root@node1:~# kubectl get all -n example
NAME                            READY   STATUS    RESTARTS        AGE
pod/backend-6b55f869fd-5mnxq    1/1     Running   0               12m
pod/backend-6b55f869fd-xfsdr    1/1     Running   0               44s
pod/frontend-6b5b58d5f8-97cmm   1/1     Running   3 (9m53s ago)   12m
pod/frontend-6b5b58d5f8-zszmq   1/1     Running   0               44s
pod/postgres-fbd8f9f49-n89tl    1/1     Running   0               13m

NAME                       TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
service/backend-service    ClusterIP   10.96.194.109   <none>        5000/TCP   12m
service/frontend-service   ClusterIP   10.96.95.46     <none>        3000/TCP   12m
service/pg-service         ClusterIP   10.96.66.228    <none>        5432/TCP   13m

NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/backend    2/2     2            2           12m
deployment.apps/frontend   2/2     2            2           12m
deployment.apps/postgres   1/1     1            1           13m

NAME                                  DESIRED   CURRENT   READY   AGE
replicaset.apps/backend-6b55f869fd    2         2         2       12m
replicaset.apps/frontend-6b5b58d5f8   2         2         2       12m
replicaset.apps/postgres-fbd8f9f49    1         1         1       13m

NAME                                           REFERENCE             TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
horizontalpodautoscaler.autoscaling/backend    Deployment/backend    26%/50%, 0%/50%   2         10        2          60s
horizontalpodautoscaler.autoscaling/frontend   Deployment/frontend   0%/80%            2         2         2          60s

示例应用功能解析

服务调用和发布

查看 backend 的pod

kubectl get pods --selector=app=backend -n example -o wide

root@node1:~# kubectl get pods --selector=app=backend -n example -o wide
NAME                       READY   STATUS    RESTARTS   AGE     IP            NODE                 NOMINATED NODE   READINESS GATES
backend-6b55f869fd-5mnxq   1/1     Running   0          5h31m   10.244.0.11   kind-control-plane   <none>           <none>
backend-6b55f869fd-xfsdr   1/1     Running   0          5h20m   10.244.0.13   kind-control-plane   <none>           <none>

特别关注某个pod的ip地址，并记录，比如 10.244.0.11

查看服务

kubectl get service -n example

root@node1:~# kubectl get svc -n example
NAME               TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
backend-service    ClusterIP   10.96.194.109   <none>        5000/TCP   5h32m
frontend-service   ClusterIP   10.96.95.46     <none>        3000/TCP   5h32m
pg-service         ClusterIP   10.96.66.228    <none>        5432/TCP   5h33m

特比关注backend-service 的 ip 地址，比如 10.96.194.109

进入到某个前端的pod，进行测试

kubectl exec -it $(kubectl get pods --selector=app=frontend -n example -o jsonpath="{.items[0].metadata.name}") -n example -- sh

访问此前记录的后端pod ip

wget -O - http://10.244.0.11:5000/healthy

root@node1:~# kubectl exec -it $(kubectl get pods --selector=app=frontend -n example -o jsonpath="{.items[0].metadata.name}") -n example -- sh
/frontend # wget -O - http://10.244.0.11:5000/healthy
Connecting to 10.244.0.11:5000 (10.244.0.11:5000)
writing to stdout
{"healthy":true}
-                    100% |***************************************************************************************************************|    17  0:00:00 ETA
written to stdout

访问 backend-service 的service ip

while true; do wget -q -O- http://10.96.194.109:5000/host_name && sleep 1; done

/frontend # while true; do wget -q -O- http://10.96.194.109:5000/host_name && sleep 1; done
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
^C

使用backend-service的完全限定域名 backend-service.example.svc.cluster.local 进行访问

while true; do wget -q -O- http://backend-service.example.svc.cluster.local:5000/host_name && sleep 1; done

/frontend # while true; do wget -q -O- http://backend-service.example.svc.cluster.local:5000/host_name && sleep 1; done
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
^C

使用backend-service的相对域名 backend-service 进行访问

while true; do wget -q -O- http://backend-service:5000/host_name && sleep 1; done

/frontend # while true; do wget -q -O- http://backend-service:5000/host_name && sleep 1; done
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-xfsdr"}
{"host_name":"backend-6b55f869fd-5mnxq"}
{"host_name":"backend-6b55f869fd-5mnxq"}
^C

退出pod

/frontend # exit
command terminated with exit code 130
root@node1:~#

应用配置

连接到后端应用pod查看 env

kubectl exec -it $(kubectl get pods --selector=app=backend -n example -o jsonpath="{.items[0].metadata.name}") -n example -- sh

env | grep DATABASE

root@node1:~# kubectl exec -it $(kubectl get pods --selector=app=backend -n example -o jsonpath="{.items[0].metadata.name}") -n example -- sh
# env | grep DATABASE
DATABASE_USERNAME=postgres
DATABASE_PASSWORD=postgres
DATABASE_URI=pg-service

exit

连接到数据库 pod 查看 configmap

kubectl exec -it $(kubectl get pods --selector=app=database -n example -o jsonpath="{.items[0].metadata.name}") -n example -- sh

ls  /docker-entrypoint-initdb.d

cat /docker-entrypoint-initdb.d/CreateDB.sql

root@node1:~# kubectl exec -it $(kubectl get pods --selector=app=database -n example -o jsonpath="{.items[0].metadata.name}") -n example -- sh
# ls  /docker-entrypoint-initdb.d
CreateDB.sql
# cat /docker-entrypoint-initdb.d/CreateDB.sql
CREATE TABLE text (
    id serial PRIMARY KEY,
    text VARCHAR ( 100 ) UNIQUE NOT NULL
);#

exit

应用扩缩容

查看HPA设置

kubectl get hpa -n example

root@node1:~# kubectl get hpa -n example
NAME       REFERENCE             TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
backend    Deployment/backend    28%/50%, 0%/50%   2         10        2          17h
frontend   Deployment/frontend   0%/80%            2         2         2          17h

查看pod数量

kubectl get pod -n example

root@node1:~# kubectl get pod -n example
NAME                        READY   STATUS    RESTARTS      AGE
backend-6b55f869fd-59vcn    1/1     Running   0             17h
backend-6b55f869fd-mbppw    1/1     Running   0             17h
frontend-6b5b58d5f8-4h5tz   1/1     Running   3 (16h ago)   17h
frontend-6b5b58d5f8-s2pm6   1/1     Running   1 (16h ago)   17h
postgres-fbd8f9f49-dsdr7    1/1     Running   0             17h

访问 http://192.168.1.231/api/ab

查看pod的性能负载，可以观察到已经开始横向扩容了

kubectl top pod -n example

root@node1:~# kubectl top pod -n example
NAME                        CPU(cores)   MEMORY(bytes)
backend-6b55f869fd-59vcn    255m         38Mi
backend-6b55f869fd-l5tlz    39m          33Mi
backend-6b55f869fd-mbppw    1m           35Mi
frontend-6b5b58d5f8-4h5tz   1m           183Mi
frontend-6b5b58d5f8-s2pm6   1m           172Mi
postgres-fbd8f9f49-dsdr7    1m           31Mi

查看 HPA

kubectl get hpa -n example

root@node1:~# kubectl get hpa -n example
NAME       REFERENCE             TARGETS             MINPODS   MAXPODS   REPLICAS   AGE
backend    Deployment/backend    27%/50%, 100%/50%   2         10        4          17h
frontend   Deployment/frontend   0%/80%              2         2         2          17h

多刷新几次页面，让性能负荷暴涨，再次观察HPA和pod

root@node1:~# kubectl get hpa -n example
NAME       REFERENCE             TARGETS             MINPODS   MAXPODS   REPLICAS   AGE
backend    Deployment/backend    30%/50%, 198%/50%   2         10        8          17h
frontend   Deployment/frontend   0%/80%              2         2         2          17h
root@node1:~# kubectl get pod -n example
NAME                        READY   STATUS    RESTARTS      AGE
backend-6b55f869fd-59vcn    1/1     Running   0             17h
backend-6b55f869fd-5vv9h    0/1     Pending   0             13s
backend-6b55f869fd-dc7mk    0/1     Pending   0             28s
backend-6b55f869fd-l5tlz    1/1     Running   0             4m43s
backend-6b55f869fd-lcgb4    0/1     Pending   0             28s
backend-6b55f869fd-mbppw    1/1     Running   0             17h
backend-6b55f869fd-pg5wp    0/1     Pending   0             28s
backend-6b55f869fd-rdwpb    1/1     Running   0             4m43s
backend-6b55f869fd-rr8s2    0/1     Pending   0             28s
backend-6b55f869fd-xx4gq    0/1     Pending   0             13s
frontend-6b5b58d5f8-4h5tz   1/1     Running   3 (17h ago)   17h
frontend-6b5b58d5f8-s2pm6   1/1     Running   1 (17h ago)   17h
postgres-fbd8f9f49-dsdr7    1/1     Running   0             17h

后记

本课程体系旨在为学员提供一套全面的云原生技术学习路径，包括容器技术、Kubernetes 部署和管理、Ingress 管理、持久化存储、应用部署、可观测性、服务网格、DevOps 工具链和流水线以及 GitOps 等方面的内容。通过学习这套课程体系，学员将掌握云原生技术的关键概念、原理和实践方法，从而提升云原生应用的部署、管理和协作效率。

1. Docker 技术实战：学习容器技术的基础知识，包括 Docker 的运作原理、核心组件以及应用部署和监控管理。
2. Kubernetes 部署和管理实战：深入了解 Kubernetes 的核心概念和基础组件，掌握 Kubernetes 集群的部署、管理和监控技能。
3. Kubernetes Ingress 管理与运维：学习 Kubernetes Ingress 的概念、工作机制和运维管理方法，提升 Ingress 的部署和管理能力。
4. Kubernetes 持久化存储实践：探讨 Kubernetes 持久化存储的原理、实现方式和实际应用，提高在 Kubernetes 上实现持久化存储的能力。
5. Kubernetes 应用部署和管理：学习 Kubernetes 应用部署和管理的基本概念、原理和实现方法，掌握在 Kubernetes 上部署和管理应用的技巧。
6. Kubernetes 可观测性实践：研究 Kubernetes 可观测性实践的概念、原理和实现方法，涉及监控、日志记录和分析等方面。
7. 基于 Istio 的服务网格实战：深入了解基于 Istio 的服务网格概念、原理和实现方法，包括服务路由、流量管理、弹性能力和微服务可观测性等。
8. DevOps 工具链与流水线实践：探讨 DevOps 工具链与流水线的概念、原理和实现方法，涵盖自动化构建、测试、部署和监控等环节。
9. GitOps 云原生应用的高效部署与管理：全面掌握 GitOps 原理、技术和工具，提高云原生应用部署、管理和协作效率。

通过对这九门课程的学习，学员可以：

1. 熟练运用 Docker 和 Kubernetes 进行容器化应用的部署和管理。
2. 掌握 Ingress 和持久化存储在 Kubernetes 集群中的配置和管理方法。
3. 了解 Kubernetes 可观测性实践，提高应用监控、日志和分析的能力。
4. 探究 Istio 服务网格的原理和实现，实现微服务的高可用、弹性和安全。
5. 运用 DevOps 工具链和流水线实现自动化构建、测试、部署和监控。
6. 掌握 GitOps 的原理和技术，提升云原生应用的部署、管理和协作效率。

本课程体系适合对云原生技术感兴趣的开发者、运维工程师、架构师等专业人士。课程内容丰富、实践性强，旨在帮助学员在实际工作中更好地应用云原生技术，为企业的数字化转型做出贡献。

如果希望获得更详细的课程介绍，请联系： info@cloudzun.com