HAProxy 第 7 层负载均衡参考实现

Google Distributed Cloud (GDC) 网闸隔离配置提供内置的代管式第 4 层 (L4) 负载均衡器，但许多企业应用需要高级第 7 层 (L7) 功能，例如基于主机的路由、集中式 TLS 管理和复杂的流量分配。过去，这是通过 Ingress API 实现的，该 API 现在在 Kubernetes 社区中被视为功能冻结。

此参考架构提供自行管理的第 7 层负载均衡解决方案。通过在 GDC 标准集群上部署热门的 HAProxy 开源控制器，客户可以将 L7 流量无缝路由到混合环境。此架构使用 TLS 终结 (HTTPRoute)，根据服务器名称指示 (SNI) 将流量路由到内置容器化 Pod 和托管在外部虚拟机上的应用。

架构

GDC 网闸隔离配置上的 HAProxy 第 7 层负载均衡架构图。

该解决方案的关键组件包括：

  • 客户端：发起 HTTPS 请求以与应用交互的实体。
  • GDC 标准集群：GDC 提供了一种内置方法来创建 Kubernetes Vanilla 集群。在此解决方案中，集群将托管 L7 负载均衡器及其控制器，以及外部虚拟机的工作负载和无头服务
  • GDC L4 负载均衡器：内置的 L4 负载均衡器，用作入口点，将 TCP/443 流量直接分发到运行控制器的 Kubernetes Pod。
  • Ingress 控制器：在标准集群中运行的 HAProxy 运算符。它们会监控 Ingress 资源并动态更新底层代理。以下实现中将使用 HAProxy Ingress 控制器
  • Ingress：标准化的 Kubernetes 资源，用于定义物理监听端口 (443) 和基于 SNI 的主机路由规则（具有 TLS 终结）。
  • 容器化工作负载 (Pod)：使用常规 Kubernetes Service 在内部公开的标准 Kubernetes 部署。
  • 基于虚拟机的工作负载（外部）：托管在项目网络上的外部虚拟机上的工作负载，使用无头 Kubernetes Service 和包含虚拟机直接 IP 的自定义端点向代理公开。
  • Harbor Registry：一个私有 Container Registry，用于在经过网闸隔离的环境中存储和提供代理和应用映像。

在标准集群中，您需要创建三个命名空间：

  • load-balancer 命名空间托管 HAProxy Ingress 控制器和 HAProxy 负载均衡器工作负载：

    负载均衡器命名空间资源。

  • hello-app 命名空间托管 Deployment、Service 和 Ingress，用于演示容器工作负载：

    hello-app 命名空间资源。

  • vm-app 命名空间托管一个无头服务（用于公开外部虚拟机 IP）、一个指向外部 IP 的 EndpointSlice 以及一个 Ingress：

    vm-app 命名空间资源。

准备工作

在部署此解决方案之前，请确保您已满足以下前提条件：

  • 所需软件：helm、docker、kubectl

  • CLI 登录和本地设置：从 GDC 控制台下载 gdcloud CLI，并在本地设置环境：

    export USER_NAME="USER_NAME"
export PROJECT_ID="PROJECT_ID"
export ZONE="ZONE"
export ORG_NAME="ORG_NAME"
export GDC_URL="GDC_URL"

gdcloud components install gdcloud-k8s-auth-plugin

gdcloud config set core/organization_console_url \
  https://console.$ORG_NAME.$ZONE.$GDC_URL
gdcloud config set core/zone $ZONE
gdcloud config set core/project ${PROJECT_ID}

gdcloud auth login # use --login-config-cert option in case of TLS error

  • 项目设置：在 GDC 网闸隔离配置环境中创建一个项目，用于存放资源：

    gdcloud projects create $PROJECT_ID

  • IAM 角色：向您的用户授予集群管理员和标准集群管理员角色以管理 Kubernetes 资源，并授予 Harbor 实例管理员角色以推送映像：

    # Grant standard cluster and cluster admin roles
gdcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="user:${USER_NAME}" \
  --role=cluster-admin

gdcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="user:${USER_NAME}" \
  --role=standard-cluster-admin

# Grant Harbor instance admin role
gdcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="user:${USER_NAME}" \
  --role=harbor-instance-admin

创建标准集群

本部分将指导您在 GDC 网闸隔离配置环境中设置标准 Kubernetes 集群。标准集群为部署各种工作负载（包括 HAProxy Ingress 控制器和自定义应用）提供了灵活而强大的基础。以下步骤将确保您的集群已正确配置，并且可供后续部署访问。

  1. 通过运行以下命令来确定可用的虚拟机映像类型：

    gdcloud compute machine-types list

  2. 为集群工作器节点选择合适的机器类型。对于本教程，建议使用至少具有 4 个 vCPU 的机器类型。

    export MACHINE_TYPE="MACHINE_TYPE"

  3. 获取管理 API 服务器 kubeconfig 并设置别名：

    export CLUSTER_NAME="CLUSTER_NAME"

KUBECONFIG=kubeconfig-admin.yaml gdcloud clusters \
  get-credentials ${ORG_NAME}-admin

alias km="kubectl --kubeconfig kubeconfig-admin.yaml"

  4. 创建包含两个工作器节点的标准集群：

    km create -f - <<EOF
apiVersion: cluster.gdc.goog/v1
kind: Cluster
metadata:
  name: ${CLUSTER_NAME}
  namespace: ${PROJECT_ID}
spec:
  nodePools:
  - machineTypeName: ${MACHINE_TYPE}
    nodeCount: 2
    name: ${CLUSTER_NAME}-node-pool
EOF

    如需详细了解可用选项，请参阅文档。

    标准集群创建过程最多可能需要 60 分钟才能完成。如需检查状态，请使用以下命令：

    km get clusters/${CLUSTER_NAME} \
  -n ${PROJECT_ID} \
  --watch

    集群准备就绪后，输出应显示“正在运行”状态，如下所示：

    NAME         STATE     K8S VERSION
my-cluster   Running   1.30.12-gke.300

  5. 集群准备就绪后，检索其凭据：

    KUBECONFIG=kubeconfig-${CLUSTER_NAME}.yaml gdcloud clusters \
  get-credentials ${CLUSTER_NAME} \
  --standard \
  --project ${PROJECT_ID} \
  --zone ${ZONE}

  6. 创建一个别名，以便在本指南的其余部分中使 kubectl 命令更加简洁。此别名将用于与标准集群进行交互：

    alias kk="kubectl --kubeconfig kubeconfig-${CLUSTER_NAME}.yaml"

  7. 为控制器、“hello-app”演示容器化应用和基于虚拟机的演示应用创建命名空间：

    kk create namespace load-balancer
kk create namespace hello-app
kk create namespace vm-app

创建并集成 Harbor Registry

Harbor 是一个容器映像注册表，在 GDC 网闸隔离配置中提供内置支持。本部分将引导您完成将 Harbor Registry 与标准集群集成的步骤，包括配置凭证和 Secret 以实现安全地拉取和推送映像。

  1. 在项目中创建 Harbor 实例。
  2. 在 Harbor 实例中创建 Harbor 项目。

  3. 设置环境变量：

    export HARBOR_INSTANCE_NAME="HARBOR_INSTANCE_NAME"
export HARBOR_INSTANCE_URL="HARBOR_INSTANCE_URL"
export HARBOR_PROJECT="HARBOR_PROJECT"
export IMAGE_PULL_SECRET_NAME="harbor-secret"

  4. 使用机器人账号登录 Harbor 实例：

    docker --config=./docker login ${HARBOR_INSTANCE_URL}

  5. 在标准集群中创建 Secret：

    kk create secret docker-registry ${IMAGE_PULL_SECRET_NAME} \
  --from-file=.dockerconfigjson=./docker/config.json \
  -n load-balancer

kk create secret docker-registry ${IMAGE_PULL_SECRET_NAME} \
  --from-file=.dockerconfigjson=./docker/config.json \
  -n hello-app

部署演示容器化应用

本部分详细介绍了如何在 GDC 网闸隔离配置 Kubernetes 集群中部署演示版容器化应用 (hello-app)。您将创建必要的 Kubernetes Deployment 和 Service 资源，以运行 hello-app 并在集群内部公开它，从而为使用 L7 负载均衡器进行访问做好准备。

  1. 将示例容器化应用的示例映像上传到 Harbor：

    docker pull gcr.io/google-samples/hello-app:1.0 \
  --platform linux/amd64
docker tag gcr.io/google-samples/hello-app:1.0 \
  ${HARBOR_INSTANCE_URL}/${HARBOR_PROJECT}/hello-app:1.0
docker --config=./docker push \
  ${HARBOR_INSTANCE_URL}/${HARBOR_PROJECT}/hello-app:1.0

  2. 在标准集群中部署以下清单：

    cat << EOF > hello-app.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-app
  namespace: hello-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello-app
  template:
    metadata:
      labels:
        app: hello-app
    spec:
      containers:
      - name: hello-server
        image: ${HARBOR_INSTANCE_URL}/${HARBOR_PROJECT}/hello-app:1.0
        ports:
        - containerPort: 8080
      imagePullSecrets:
      - name: ${IMAGE_PULL_SECRET_NAME}
---
apiVersion: v1
kind: Service
metadata:
  name: hello-app
  namespace: hello-app
spec:
  type: ClusterIP
  selector:
    app: hello-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
EOF

kk apply -f hello-app.yaml

然后验证部署和服务是否存在

kk get svc,deploy -n hello-app

在虚拟机中部署演示应用

本部分详细介绍了如何在 Kubernetes 集群外部的虚拟机 (VM) 中部署演示应用。通过在虚拟机上设置 HTTP 服务器，您将模拟负载均衡器可以公开的外部应用，从而展示其管理集群内外资源流量的能力。

首先，为演示应用创建一个虚拟机：

  1. 在网络浏览器中打开 GDC 控制台。
  2. 选择您在其中创建标准 Kubernetes 集群的项目。
  3. 打开菜单，然后点击虚拟机。
  4. 点击创建实例。
  5. 将虚拟机命名为 vm-workload。2 vCPU 映像足以满足示例要求。
  6. 对于启动磁盘映像，请选择预装了 Python 的 Ubuntu 22.04 发行版。
  7. 点击创建。
  8. 等待几分钟，直到虚拟机准备就绪。
  9. 建立与虚拟机的 SSH 连接：
    1. 在 GDC 控制台中，点击该虚拟机。
    2. 点击通过 SSH 连接。

连接到 SSH 控制台后，运行以下命令：

mkdir ~/simple-server
cd ~/simple-server
echo 'Welcome to my VM!' > index.html
python3 -m http.server --bind 0.0.0.0 8080 &

如需将流量路由到虚拟机，请创建无头 Service（不含选择器）。此地址将使用 EndpointSlice 资源手动映射到虚拟机的内部 IP 地址。

kk apply -f - <<EOF
apiVersion: v1
kind: Service
metadata:
  name: vm-app-svc
  namespace: vm-app
spec:
  ports:
  - protocol: TCP
    port: 443
    targetPort: 443
EOF

通过运行以下命令获取 vm-workload 虚拟机的 IP 地址

gdcloud compute instances list --project ${PROJECT_ID} \
  | grep workload-vm | awk '{print $3}'

输出将是设置 EndpointSlice 资源所需的虚拟机的 IP 地址。

创建资源 EndpointSlice，该资源将连接到虚拟机应用无选择器 Service，并指定应将流量路由到的虚拟机的 IP。

apiVersion: discovery.k8s.io/v1
kind: EndpointSlice
metadata:
  name: vm-app-endpoints
  namespace: vm-app
  labels:
    kubernetes.io/service-name: vm-app-svc
addressType: IPv4
ports:
  - port: 8080
endpoints:
  - addresses:
    - "VM_IP"
    conditions:
      ready: true

创建自签名证书

本部分将指导您完成创建 TLS 证书和 Kubernetes Secret 的过程，以确保基于容器和基于虚拟机的应用的安全通信。为方便起见，本指南使用自签名证书，但在生产环境中，您必须使用生产级证书，如可选：使用可用于生产用途的证书中所述。为这些应用选择任意示例域名。通过建立安全连接，您可以确保通过 HAProxy Ingress 控制器访问应用的客户端的数据完整性和机密性。

对于容器化应用，我们会创建一个自签名证书，并将其作为 Secret 保存在负载均衡器命名空间中。在请求 k8s-app.example.com 时，此证书将用于 TLS

openssl req -x509 -newkey rsa:2048 -nodes \
  -keyout tls-containerized.key \
  -out tls-containerized.crt \
  -subj "/CN=k8s-app.example.com" \
  -days 365

kk create secret tls tls-containerized \
  --namespace load-balancer \
  --key tls-containerized.key \
  --cert tls-containerized.crt

kk create secret tls tls-containerized \
  --namespace hello-app \
  --key tls-containerized.key \
  --cert tls-containerized.crt

对于虚拟机应用，系统会颁发并保存类似的自签名证书。在请求 vm-app.example.com 时，此证书将用于 TLS

openssl req -x509 -newkey rsa:2048 -nodes \
  -keyout tls-vm.key \
  -out tls-vm.crt \
  -subj "/CN=vm-app.example.com" \
  -days 365

kk create secret tls tls-vm \
  --namespace load-balancer \
  --key tls-vm.key \
  --cert tls-vm.crt

kk create secret tls tls-vm \
  --namespace vm-app \
  --key tls-vm.key \
  --cert tls-vm.crt

部署 HAProxy

安装 HAProxy Ingress 控制器和 L4 LB

export HAPROXY_VERSION=3.1.14

# pull the HAProxy Ingress Controller image and push it to Harbor
docker pull haproxytech/kubernetes-ingress:${HAPROXY_VERSION} \
  --platform linux/amd64
docker tag haproxytech/kubernetes-ingress:${HAPROXY_VERSION} \
  ${HARBOR_INSTANCE_URL}/${HARBOR_PROJECT}/haproxy-ingress:${HAPROXY_VERSION}
docker --config=./docker push \
  ${HARBOR_INSTANCE_URL}/${HARBOR_PROJECT}/haproxy-ingress:${HAPROXY_VERSION}

# Get Helm repo
helm repo add haproxytech https://haproxytech.github.io/helm-charts
helm repo update

# Install the Ingress Controller with helm
helm upgrade --install haproxy-kubernetes-ingress \
  haproxytech/kubernetes-ingress \
  --kubeconfig kubeconfig-${CLUSTER_NAME}.yaml \
  --namespace load-balancer \
  --set controller.image.repository=${HARBOR_INSTANCE_URL}/${HARBOR_PROJECT}/haproxy-ingress \
  --set controller.image.tag=${HAPROXY_VERSION} \
  --set controller.existingImagePullSecret=${IMAGE_PULL_SECRET_NAME} \
  --set controller.service.type=LoadBalancer \
  --set-json \
  controller.service.annotations='{"networking.gke.io/load-balancer-type": "internal"}'

HAProxy Ingress 控制器使用 LoadBalancer 类型服务获取用于客户端访问的唯一虚拟 IP 地址。此服务会设置全托管式第 4 层负载均衡器。为简单起见，本指南通过将 load-balancer-type 注解设置为 internal 来创建内部负载均衡器。省略此注解会导致创建外部负载均衡器。Kubernetes 部署使用提供的 Secret (${IMAGE_PULL_SECRET_NAME}) 从 Harbor 安全地拉取映像，该 Secret 包含 Harbor 机器人账号的凭据。

验证 HAProxy Ingress 控制器安装

检查 HAProxy Ingress 控制器的 Pod 是否正在运行且已准备就绪：

kk get pods -n load-balancer

输出应如下所示：

NAME                                          READY   STATUS      RESTARTS   AGE
haproxy-kubernetes-ingress-78dc9c8676-f8fcb   1/1     Running     0          35s
haproxy-kubernetes-ingress-78dc9c8676-lfnr2   1/1     Running     0          65s
haproxy-kubernetes-ingress-crdjob-3-tgj2h     0/1     Completed   0          65s

检查 HAProxy Ingress 控制器的服务是否已创建并配置：

kk get services -n load-balancer

输出类似于以下内容：

NAME                         TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)                                                                  AGE
haproxy-kubernetes-ingress   LoadBalancer   10.252.27.46   10.252.4.17   80:32023/TCP,443:31103/TCP,443:31103/UDP,1024:30146/TCP,6060:30718/TCP   10m

为演示应用定义 Ingress 资源

创建将 HAProxy 连接到容器化应用 Service 的 Ingress 资源

cat << EOF > hello-app-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: hello-app-ingress
  namespace: hello-app
  annotations:
    haproxy.org/ssl-redirect: "true"
    haproxy.org/ssl-redirect-port: "443"
    haproxy.org/ssl-redirect-code: "308"
spec:
  ingressClassName: haproxy
  tls:
  - hosts:
    - "k8s-app.example.com"
    secretName: tls-containerized
  rules:
  - host: "k8s-app.example.com"
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: hello-app
            port:
              number: 80
EOF

kk apply -f hello-app-ingress.yaml

创建 Ingress 资源，该资源将连接到无选择器的虚拟机应用 Service，并指定应将流量路由到的虚拟机的 IP 地址。

cat << EOF > vm-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: vm-app-ingress
  namespace: vm-app
  annotations:
    haproxy.org/ssl-redirect: "true"
    haproxy.org/ssl-redirect-port: "443"
    haproxy.org/ssl-redirect-code: "308"
spec:
  ingressClassName: haproxy
  tls:
  - hosts:
    - "vm-app.example.com"
    secretName: tls-vm
  rules:
  - host: "vm-app.example.com"
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: vm-app-svc
            port:
              number: 443
EOF

kk apply -f vm-ingress.yaml

检索负载均衡器 IP 地址

运行命令以获取负载均衡器的 IP 地址。

kk get services/haproxy-kubernetes-ingress \
  -n load-balancer \
  -o jsonpath='{.status.loadBalancer.ingress[0].ip}'

在验证对应用的访问权限时，您需要用到这些信息。此项称为 LOAD_BALANCER_IP。

创建客户端虚拟机

按照以下步骤创建客户端虚拟机：

  1. 在网络浏览器中打开 GDC 控制台。
  2. 打开菜单，然后点击虚拟机。
  3. 点击创建实例。
  4. 创建一个名为 client 的虚拟机，选择小型机器类型，然后选择预装了 curl 的 Rocky Linux 或 Ubuntu。
  5. 点击创建。
  6. 等待几分钟，直到虚拟机准备就绪。
  7. 虚拟机准备就绪后，与虚拟机建立 SSH 连接：
    1. 在 GDC 控制台中，点击该虚拟机。
    2. 点击通过 SSH 连接。

验证已验证访问权限和路由

如需测试路由，请从客户端虚拟机执行 curl 命令。您可以使用这两个应用定义的域名和负载均衡器的 IP 地址连接到这两个应用。

通过在 curl 中传递 --resolve 标志，您可以强制将域名解析为 GDC 网闸隔离配置 L4 负载均衡器的 IP。请注意，我们传递了 -k 标志来信任自签名证书。

测试 Kubernetes 容器化应用：

curl -k --resolve k8s-app.example.com:443:$LOAD_BALANCER_IP https://k8s-app.example.com -v

测试外部虚拟机应用：

curl -k --resolve vm-app.example.com:443:$LOAD_BALANCER_IP https://vm-app.example.com -v

如果配置正确，Ingress 控制器将无缝充当 TLS 终结器，并将流量传递到目的地。

可选：使用可用于生产用途的证书

本部分介绍了如何利用 GDC 网闸隔离配置 CA Service 创建私有根证书授权机构 (CA)、为工作负载颁发签名证书，以及安全地更新 GDC 网闸隔离配置标准集群和客户端虚拟机。

本部分概述了如何使用 GDC 网闸隔离配置 CA Service 创建私有根证书授权机构 (CA)，并为您的应用颁发有效证书。通过在客户端虚拟机上安装此根 CA，您可以验证 TLS 终结是否可与可信证书无缝搭配使用，而无需绕过 SSL 警告（例如，使用 curl -k）。

授予必要权限并获取凭证

如需管理 CA Service 和颁发证书，您的用户需要在项目中拥有适当的 IAM 角色。

  1. 授予 certificate-authority-service-admin 和 certificate-requester 角色：

    gdcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member=user:${USER_NAME} \
  --role=certificate-authority-service-admin

gdcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member=user:${USER_NAME} \
  --role=certificate-requester

  2. 获取 Management API 服务器的凭据：

    gdcloud clusters get-credentials ${ORG_NAME}-admin

创建根 CA

您将在项目命名空间内的 Management API 服务器中创建证书授权机构。

  1. 应用 CertificateAuthority 资源：

    km apply -f - <<EOF
apiVersion: pki.security.gdc.goog/v1
kind: CertificateAuthority
metadata:
  name: my-root-ca
  namespace: ${PROJECT_ID}
spec:
  caProfile:
    commonName: "My Root CA"
    duration: 87600h # 10 years
    keyAlgorithm: RSA_2048
    maxChainLength: 1
  caType: ROOT
  keyLocation: HSM
  rotationPolicy:
    cronTime: 0 0 1 1 *
EOF

    km -n ${PROJECT_ID} get \
certificateauthority.pki.security.gdc.goog/my-root-ca -ojson \
| jq -r '
.status.conditions[] | select( .type as $id | "Ready" | index($id)) .status'

颁发和部署证书

CA 准备就绪后，您将为容器化应用和基于虚拟机的应用请求证书。这些请求在 Management API 服务器中发生，并且生成的密钥必须移至标准集群。

为这两个网域创建请求：

km apply -f - <<EOF
apiVersion: pki.security.gdc.goog/v1
kind: CertificateRequest
metadata:
  name: tls-containerized-req
  namespace: ${PROJECT_ID}
spec:
  certificateAuthorityRef:
    name: my-root-ca
    namespace: ${PROJECT_ID}
  certificateConfig:
    subjectConfig:
      commonName: "k8s-app.example.com"
      dnsNames:
      - "k8s-app.example.com"
  signedCertificateSecret: tls-containerized-signed
---
apiVersion: pki.security.gdc.goog/v1
kind: CertificateRequest
metadata:
  name: tls-vm-req
  namespace: ${PROJECT_ID}
spec:
  certificateAuthorityRef:
    name: my-root-ca
    namespace: ${PROJECT_ID}
  certificateConfig:
    subjectConfig:
      commonName: "vm-app.example.com"
      dnsNames:
      - "vm-app.example.com"
  signedCertificateSecret: tls-vm-signed
EOF

请稍等片刻，等待证书签发。当 Ready 条件为 True 时，您可以验证它们是否已准备就绪：

km get certificaterequests -n ${PROJECT_ID}

更新标准集群

如果您按照本指南的前面部分操作，则标准集群中会有自签名 Secret。您必须先删除这些版本，然后才能创建新的签名版本：

kk delete secret tls-containerized -n load-balancer
kk delete secret tls-vm -n load-balancer

kk delete secret tls-containerized -n hello-app
kk delete secret tls-vm -n vm-app

现在，从 Management API 服务器中提取已签名的证书，并在标准集群中创建新的 Secret。

km get secret -n ${PROJECT_ID} tls-containerized-signed \
  -o jsonpath='{.data.tls\.crt}' \
  | base64 -d > tls-containerized.crt

km get secret -n ${PROJECT_ID} tls-containerized-signed \
  -o jsonpath='{.data.tls\.key}' \
  | base64 -d > tls-containerized.key

kk create secret tls tls-containerized \
  --namespace load-balancer \
  --key tls-containerized.key \
  --cert tls-containerized.crt

kk create secret tls tls-containerized \
  --namespace hello-app \
  --key tls-containerized.key \
  --cert tls-containerized.crt

km get secret -n ${PROJECT_ID} tls-vm-signed \
  -o jsonpath='{.data.tls\.crt}' \
  | base64 -d > tls-vm.crt

km get secret -n ${PROJECT_ID} tls-vm-signed \
  -o jsonpath='{.data.tls\.key}' \
  | base64 -d > tls-vm.key

kk create secret tls tls-vm \
  --namespace load-balancer \
  --key tls-vm.key \
  --cert tls-vm.crt

kk create secret tls tls-vm \
  --namespace vm-app \
  --key tls-vm.key \
  --cert tls-vm.crt

负载均衡器会自动获取并刷新新密钥。

配置客户端信任

如需验证设置，您需要让客户端虚拟机信任新的根 CA。

将根 CA 证书提取到文件中：

km get secret -n ${PROJECT_ID} my-root-ca-secret \
  -o jsonpath='{.data.tls\.crt}' \
  | base64 -d > my-root-ca.crt

将证书转移到客户端虚拟机。（您可以复制 my-root-ca.crt 的内容，并将其粘贴到客户端虚拟机上的文件中）。

在客户端虚拟机上，更新受信任证书存储区。

如果 client 虚拟机是 Ubuntu：

sudo cp my-root-ca.crt /usr/local/share/ca-certificates/
sudo chmod 644 /usr/local/share/ca-certificates/my-root-ca.crt
sudo update-ca-certificates

如果 client 虚拟机是 Rocky Linux：

sudo cp my-root-ca.crt /etc/pki/ca-trust/source/anchors/
sudo update-ca-trust

验证访问权限

现在，您可以使用 curl 访问应用，而无需使用 -k 标志。连接将完全受信任。

测试 k8s 容器化应用：

curl -v --resolve k8s-app.example.com:443:LOAD_BALANDER_IP https://k8s-app.example.com

测试虚拟机应用：

curl -v --resolve vm.example.com:443:LOAD_BALANDER_IP https://vm-app.example.com

如果成功，您将立即看到应用输出，而不会出现任何 SSL 证书警告。