HAProxy 第 7 層負載平衡參考實作

Google Distributed Cloud (GDC) air-gapped 提供內建的第 4 層 (L4) 負載平衡器，但許多企業應用程式需要進階的第 7 層 (L7) 功能，例如以主機為基礎的路由、集中式 TLS 管理和複雜的流量分割。過去，這項作業是透過 Ingress API 完成，但 Kubernetes 社群現在認為這項功能已凍結。

這項參考架構提供自行管理的第 7 層負載平衡解決方案。在 GDC 標準叢集上部署熱門的 HAProxy 開源控制器後，客戶就能順暢地將 L7 流量轉送至混合式環境。這個架構使用 TLS 終止 (HTTPRoute)，根據伺服器名稱指示 (SNI) 將流量轉送至內建容器化 Pod，以及外部虛擬機器上託管的應用程式。

架構

GDC 氣隙環境中 HAProxy 第 7 層負載平衡的架構圖。

這項解決方案的主要元件包括：

  • 用戶端：啟動 HTTPS 要求以與應用程式互動的實體。
  • GDC 標準叢集： GDC 提供內建方式來建立 Kubernetes Vanilla 叢集。在本解決方案中，叢集將代管 L7 LB 和其控制器，以及外部 VM 的工作負載和無標頭服務。
  • GDC L4 負載平衡器：內建 L4 負載平衡器做為進入點，直接將 TCP/443 流量分配給執行控制器的 Kubernetes Pod。
  • Ingress 控制器：在標準叢集中執行的 HAProxy 運算子。他們會監控 Ingress 資源，並動態更新底層的 Proxy。下列實作項目將使用 HAProxy Ingress 控制器
  • Ingress：標準化 Kubernetes 資源，定義實體接聽埠 (443) 和以 SNI 為基礎的主機轉送規則，並終止 TLS。
  • 容器化工作負載 (Pod)：標準 Kubernetes 部署作業，透過一般 Kubernetes Service 在內部公開。
  • 以 VM 為基礎的工作負載 (外部)：工作負載託管於專案網路的外部 VM，並透過無頭 Kubernetes Service 和包含 VM 直接 IP 的自訂端點，向 Proxy 公開。
  • Harbor Registry：用於儲存及提供無網路環境中 Proxy 和應用程式映像檔的私人容器登錄檔。

在標準叢集中，您會建立三個命名空間：

  • load-balancer 命名空間會代管 HAProxy Ingress 控制器和 HAProxy 負載平衡器工作負載：

    負載平衡器命名空間資源。

  • hello-app 命名空間會代管 Deployment、Service 和 Ingress，用於示範容器工作負載：

    hello-app 命名空間資源。

  • vm-app 命名空間會代管無標題服務，該服務會公開外部 VM 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. 為叢集 worker 節點選取適當的機型。在本教學課程中，建議使用至少有 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. 建立含有兩個 worker 節點的標準叢集：

    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

    叢集準備就緒後，輸出內容應會顯示「Running」狀態，如下所示：

    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」示範容器化應用程式和 VM 型試用版應用程式建立命名空間：

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

建立及整合 Harbor 登錄檔

Harbor 是容器映像檔登錄檔，在 GDC 氣隙環境中內建支援。本節將逐步說明如何將 Harbor 登錄檔與標準叢集整合，包括設定憑證和密鑰，以安全地提取及推送映像檔。

  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. 在標準叢集中建立密鑰：

    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

在 VM 中部署示範應用程式

本節詳細說明如何在 Kubernetes 叢集外的虛擬機器 (VM) 中部署範例應用程式。在 VM 上設定 HTTP 伺服器，模擬負載平衡器可公開的外部應用程式，展示負載平衡器管理叢集內外資源流量的能力。

首先，請為試用版應用程式建立 VM：

  1. 在網路瀏覽器中開啟 GDC 控制台。
  2. 選取與您建立標準 Kubernetes 叢集時相同的專案。
  3. 開啟選單，然後按一下「虛擬機器」。
  4. 點選「建立執行個體」。
  5. 將 VM 命名為 vm-workload。2 個 vCPU 的映像檔就足以應付這個範例。
  6. 選取 Ubuntu 22.04 發行版本做為開機磁碟映像檔，這個版本已預先安裝 Python。
  7. 點選「建立」。
  8. 請稍候幾分鐘，等待 VM 準備就緒。
  9. 與 VM 建立 SSH 連線：
    1. 在 GDC 控制台中，按一下 VM。
    2. 按一下「Connect with 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 &

如要將流量轉送至 VM，請建立無標頭的 Service (不含選取器)。這會使用 EndpointSlice 資源手動對應至 VM 的內部 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 VM 的 IP 位址：

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

輸出內容是 VM 的 IP 位址，設定 EndpointSlice 資源時需要用到這個位址。

建立將連線至 VM 應用程式的資源 EndpointSlice，並指定流量應路由傳送至的 VM 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，確保容器型和 VM 型應用程式的通訊安全。為方便起見，本指南使用自行簽署的憑證，但在正式環境中，您必須使用正式版憑證，如「選用：使用正式版憑證」一節所述。為這些應用程式選擇任意範例網域名稱。建立安全連線後，透過 HAProxy Ingress Controller 存取應用程式的用戶端，就能確保資料完整性和機密性。

如果是容器化應用程式，我們會建立自行簽署的憑證，並將其儲存為負載平衡器命名空間中的密鑰。要求 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 應用程式使用。要求 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 部署作業會使用提供的密鑰 (${IMAGE_PULL_SECRET_NAME}) 從 Harbor 安全地提取映像檔，該密鑰包含 Harbor 機器人帳戶的憑證。

驗證 HAProxy Ingress 控制器安裝作業

確認 HAProxy Ingress Controller 的 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 Controller 的服務：

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 資源

建立 Ingress 資源，將 HAProxy 連線至容器化應用程式服務

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 資源，連線至沒有 VM 應用程式選取器的 Service，並為應將流量路由傳送至的 VM 設定 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。

建立用戶端 VM

請按照下列步驟建立用戶端 VM：

  1. 在網路瀏覽器中開啟 GDC 控制台。
  2. 開啟選單，然後按一下「虛擬機器」。
  3. 點選「建立執行個體」。
  4. 建立名為 client 的 VM，選取小型機型，然後選取 Rocky Linux 或 Ubuntu，這些作業系統已預先安裝 curl。
  5. 點選「建立」。
  6. 請稍候幾分鐘，等待 VM 準備就緒。
  7. VM 準備就緒後，請與 VM 建立 SSH 連線：
    1. 在 GDC 控制台中，按一下 VM。
    2. 按一下「Connect with SSH」。

驗證存取權和路徑

如要測試路由，請從用戶端 VM 執行 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

測試外部 VM 應用程式：

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

如果設定正確，Ingress 控制器會順暢地充當 TLS 終止程式，並將流量傳遞至目的地。

選用：使用可用於正式環境的憑證

本節說明如何運用 GDC 氣隙 CA 服務建立私人根憑證授權單位 (CA)、為工作負載核發已簽署的憑證，以及安全地更新 GDC 氣隙標準叢集和用戶端 VM。

本節說明如何使用 GDC 氣隙 CA 服務建立私人根憑證授權單位 (CA)，並為應用程式核發有效憑證。在用戶端 VM 上安裝這個根 CA 後，您就能驗證 TLS 終止作業是否能順暢搭配受信任的憑證運作，不必略過 SSL 警告 (例如使用 curl -k)。

授予必要權限並取得憑證

如要管理 CA 服務及核發憑證，使用者必須在專案中具備適當的 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

    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 後，您會為容器化應用程式和 VM 型應用程式要求憑證。這些要求會在管理 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}

更新標準叢集

如果您已按照本指南先前各節的說明操作，標準叢集應已包含自行簽署的密鑰。您必須先刪除這些版本，才能建立新的簽署版本：

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 伺服器中擷取已簽署的憑證，並在標準叢集中建立新的密鑰。

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

負載平衡器會自動取得並重新整理新密鑰。

設定用戶端信任

如要驗證設定，您需要告知用戶端 VM 信任新的根 CA。

將根 CA 憑證擷取至檔案：

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

將憑證轉移至用戶端 VM。(您可以複製 my-root-ca.crt 的內容，然後貼到用戶端 VM 的檔案中)。

在用戶端 VM 上更新信任存放區。

如果 client VM 是 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 VM 是 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

測試 VM 應用程式：

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

如果成功，您會立即看到應用程式輸出內容，且不會收到任何 SSL 憑證警告。