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

Google Distributed Cloud (GDC) air-gapped 提供内置的托管式第 4 层 (L4) 负载平衡器，但许多企业应用需要高级第 7 层 (L7) 功能，例如基于主机的路由、集中式 TLS 管理和复杂的流量拆分。从历史上看，这是使用 Ingress API 完成的，但 Kubernetes 社区现在认为该 API 已冻结功能。

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

架构

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

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

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

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

  

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

  

• vm-app 命名空间托管一个无头服务，该服务公开外部虚拟机 IP、指向外部 IP 的 EndpointSlice 和 Ingress：

  

准备工作

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

• 所需软件： 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 air-gapped 中提供内置支持。本部分将引导您完成将 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)。您将创建运行 hello-app 所需的 Kubernetes Deployment 和 Service 资源，并在集群内部公开这些资源，以便使用 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. 在 Web 浏览器中打开 GDC 控制台。
2. 选择与创建标准 Kubernetes 集群时相同的项目。
3. 打开菜单，然后点击虚拟机 。
4. 点击创建实例 。
5. 为虚拟机命名为 vm-workload。对于此示例，2 个 vCPU 映像就足够了。
6. 对于启动磁盘映像，选择 Ubuntu 22.04 发行版，该发行版预安装了 Python。
7. 点击创建 。
8. 等待几分钟，直到虚拟机准备就绪。
9. 与虚拟机建立 SSH 连接：
   1. 在 GDC 控制台中，点击虚拟机。
   2. 点击 Connect with SSH （使用 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 地址。

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

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

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

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. 在 Web 浏览器中打开 GDC 控制台。
2. 打开菜单，然后点击虚拟机 。
3. 点击创建实例 。
4. 创建一个名为 client 的虚拟机，选择一个小型机器类型，然后选择 Rocky Linux 或 Ubuntu，它们都预安装了 curl。
5. 点击创建 。
6. 等待几分钟，直到虚拟机准备就绪。
7. 虚拟机准备就绪后，与虚拟机建立 SSH 连接：
   1. 在 GDC 控制台中，点击虚拟机。
   2. 点击 Connect with SSH （使用 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. 获取管理 API 服务器的凭据：

   gdcloud clusters get-credentials ${ORG_NAME}-admin
   

创建根 CA

您将在项目命名空间内的管理 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
   

   注意： 根 CA 创建过程最多可能需要 40 分钟才能完成。您可以使用以下命令监控状态。等待其返回 True，然后再继续。

   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 准备就绪后，您将为容器化应用和基于虚拟机的应用请求证书。这些请求发生在管理 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

等待片刻，让系统颁发证书。当“就绪”条件为 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

现在，从管理 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

负载平衡器会自动获取并刷新新的 Secret。

配置客户端信任

如需验证设置，您需要告知客户端虚拟机信任新的根 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 证书警告。