掌握 Pod 健康檢查與 CNI 網路實作技巧

– 33 分鐘閱讀

在 Kubernetes 的世界裡，Pod 是應用程式佈署和管理的根本。理解 Pod 的生命週期和網路設定對於建構和維護穩定的 Kubernetes 應用程式至關重要。本文將探討 Pod 的生命週期管理，包含 Pod 的各個階段、健康檢查探針的設定以及網路設定的關鍵環節。同時，文章將解析 CNI 的作用和常用外掛程式，並提供實用的 Go 程式碼範例和 Kubernetes YAML 設定範例，協助您全面理解 Kubernetes 的網路和應用程式健康檢查機制。

揭開 Pod 生命週期的神秘面紗

Pod 的生命週期包含以下幾個階段：

  graph LR
    C[C]
    D[D]
    E[E]
A[Pending] --> B(Running);
B --> C{Succeeded};
B --> D{Failed};
B --> E{Unknown};
  • Pending（待處理）： Pod 已被 Kubernetes 叢集接受，但一個或多個容器尚未建立完成。這包括 Pod 等待排程和下載容器映像檔的時間。
  • Running（執行中）： Pod 已排程到節點，所有容器都已建立。至少有一個容器正在執行、啟動或重新啟動中。
  • Succeeded（成功）： Pod 中所有容器都已成功終止，與不會重新啟動。
  • Failed（失敗）： Pod 中所有容器都已終止，與至少有一個容器終止失敗。
  • Unknown（未知）： 無法確定 Pod 的狀態，通常是由於與 Kubelet 通訊失敗造成。

Pod 健康檢查：探針的應用

Kubernetes 使用探針 (Probe) 來監控 Pod 中容器的健康狀態。有三種型別的探針：

  • livenessProbe（活躍性探針）： 檢查應用程式是否正在執行。若失敗，Kubernetes 會重新啟動容器。
  • readinessProbe（就緒性探針）： 檢查應用程式是否準備好接收流量。若失敗，Kubernetes 不會將流量導向該 Pod。
  • startupProbe（啟動探針）： 檢查應用程式是否已完全啟動。適用於啟動時間較長的應用程式。

探針有三種檢查方式：

  • exec： 在容器內執行指定命令。
  • TCP： 嘗試建立 TCP 連線。
  • HTTP： 傳送 HTTP 請求。

Kubernetes 網路與 CNI 的深度解析

Kubernetes 使用 Container Network Interface (CNI) 來管理 Pod 的網路。CNI 外掛程式負責為 Pod 分配 IP 地址和設定網路路由。

一些常用的 CNI 外掛程式：

  • Weave Net： 建立覆寫網路，允許 Pod 跨主機通訊。
  • Calico： 使用 BGP 路由，提供高效能和可擴充性。
  • Flannel： 使用 VXLAN 或 UDP 封裝，建立簡單的覆寫網路。
  • Canal： 結合 Flannel 和 Calico 的優點。
  • Cilium： 根據 eBPF 的高效能網路和安全解決方案。

選擇 CNI 外掛程式時，需要考量網路效能、安全性、複雜度和可擴充性等因素。

Go Web 伺服器範例與 Kubernetes 佈署實戰

以下是一個簡單的 Go Web 伺服器程式碼範例：

package main

import (
	"fmt"
	"log"
	"net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "你好，世界！這是 Golang 網頁伺服器！")
}

func main() {
	http.HandleFunc("/", helloHandler)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

這個程式碼片段建立了一個基本的 HTTP 伺服器，監聽 8080 埠，並在收到請求時回傳 “你好，世界！這是 Golang 網頁伺服器！"。

以下是一個 Kubernetes Deployment 設定範例，用於佈署 Go Web 伺服器：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-webserver
spec:
  replicas: 3
  selector:
    matchLabels:
      app: go-webserver
  template:
    metadata:
      labels:
        app: go-webserver
    spec:
      containers:
      - name: go-webserver
        image: go-webserver:latest
        ports:
        - containerPort: 8080

這個 Deployment 設定定義了名為 go-webserver 的 Deployment，它會建立 3 個 Pod 副本，每個 Pod 都執行 Go Web 伺服器容器。

接著，建立一個 Service 來暴露 Deployment：

apiVersion: v1
kind: Service
metadata:
  name: go-webserver-service
spec:
  selector:
    app: go-webserver
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

這個 Service 設定將流量從 80 埠轉發到 Pod 的 8080 埠，讓外部可以存取 Go Web 伺服器。

Go 程式碼範例：模擬 Bridge 網路

以下的 Go 程式碼示範如何使用系統呼叫建立和設定虛擬網路橋接 (bridge)，並將 veth pair 的其中一端連線到橋接上，另一端模擬容器的網路介面：

package main

import (
	"fmt"
	"log"
	"net"
	"os/exec"
	"strings"
)

// ... (其他函式程式碼，與原文相同)

這段 Go 程式碼示範瞭如何使用系統呼叫建立和設定一個虛擬網路橋接 (bridge)，並將 veth pair 的其中一端連線到橋接上，另一端則模擬容器的網路介面。程式碼首先建立一個名為 mybridge0 的橋接，並設定其 IP 位址為 192.168.25.1/24。接著，它建立一對虛擬乙太網路介面 (veth pair) veth0 和 veth1。veth1 被連線到 mybridge0 橋接，而 veth0 則被設定為 192.168.25.2/24，模擬容器的網路介面。最後，程式碼啟用所有建立的網路介面，並使用 ping 命令測試網路連線。這個範例展示瞭如何以程式化的方式建立和管理虛擬網路，這對於容器網路的設定和管理至關重要。

  flowchart LR
    subgraph "Host"
        A["Physical Network Interface (eth0)"]
    end
    subgraph "Bridge Network"
        B["Bridge IP: 192.168.25.1"]
        C["veth1"]
    end
    subgraph "Container Simulation"
        D["veth0: 192.168.25.2"]
    end
    A --> B
    C --> B
    D --> B

圖表説明: 這個圖表説明瞭程式碼建立的網路拓撲。主機的實體網路介面 eth0 並沒有直接與 Bridge 連線，此範例著重於 bridge 內部的設定與 veth pair 的連線。mybridge0 橋接網路包含 veth1 介面，而 veth0 介面則模擬容器的網路介面，並分配了 IP 位址 192.168.25.2。

透過以上步驟，我們可以將 Go Web 伺服器佈署到 Kubernetes 叢集中，並透過 CNI 提供的網路功能實作服務的存取。本文探討了 Kubernetes 中 Pod 的生命週期管理、健康檢查和網路設定。透過理解這些概念，可以更好地管理 Kubernetes 應用程式，並確保應用程式的穩定性和易用性。

深入理解 Pod 的生命週期、健康檢查和網路設定，是建構和維護穩定的 Kubernetes 應用程式的關鍵。希望這篇文章能幫助您更有效地運用這些核心概念，提升 Kubernetes 應用程式的可靠性和效能。

深入 Kubernetes CNI：架構解析與實戰演練

在 Kubernetes 的世界中，網路連通性如同血管般重要。容器網路介面 (CNI) 正是這血管系統的關鍵樞紐，它讓 Pod 能夠彼此連線，並且外部世界溝通。我將帶您深入瞭解 CNI 的架構、運作流程，並透過實際案例展現其強大功能。

  graph LR
    B[B]
    subgraph 容器化環境
        A[Kubelet] --> B{CNI Plugin}
        B --> C[網路提供商 e.g. Calico, Weave]
    end
    C --> D[底層網路基礎設施]

上圖簡潔地展示了 CNI 的核心架構：Kubelet 作為節點代理，透過 CNI Plugin 與網路提供商互動，最終將 Pod 連線到底層網路。

熱門 CNI 專案比較

選擇 CNI 方案時，需要考量專案的規模、效能需求和安全策略。以下列出幾個熱門 CNI 專案的特性比較：

專案名稱主要特性適用場景
Calico根據 BGP，網路策略豐富，安全性高大型叢集，需要精細網路控制
Cilium根據 eBPF，高效能，L7/HTTP 感知微服務架構，需要高效能網路
Weave Net快速與易於使用，建立虛擬網路小型叢集，快速佈署
Flannel簡單易用，適用於 Kubernetes中小型叢集，基本網路需求

Golang Web 伺服器範例：實踐容器連線

讓我們透過一個簡單的 Golang Web 伺服器範例，實際操作容器連線。

建置 Docker 映像

docker build -t go-web:v1 .

執行容器

docker run -d -p 80:8080 --name go-web go-web:v1

測試連線

curl http://localhost

如果一切順利，您應該會看到 “Hello” 的輸出。

這個範例程式碼建立了一個簡單的 Web 伺服器，監聽 8080 連線埠，並回傳 “Hello”。docker run 指令將容器的 8080 連線埠對映到主機的 80 連線埠，讓您可以透過 localhost 存取容器內的服務。

Dockerfile 最佳化

FROM golang:1.19 AS builder

WORKDIR /app
COPY go.mod ./
COPY go.sum ./
RUN go mod download

COPY *.go ./
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o web-server

FROM scratch
COPY --from=builder /app/web-server /
CMD ["/web-server"]

這個 Dockerfile 使用多階段建置，先在 golang:1.19 環境中編譯程式碼，再將編譯好的執行檔複製到 scratch 映像中，以最小化最終映像大小。CGO_ENABLED=0 停用 CGO，減少相依性，GOOS=linux 指定編譯目標平台為 Linux。

容器間通訊：同主機與跨主機

  • 同主機通訊： 同一主機上的容器可透過 Docker bridge 網路直接通訊。
  • 跨主機通訊： 跨主機通訊需要額外設定，例如使用 CNI 外掛程式建立覆寫網路。

CNI 外掛程式開發：Go 語言範例

以下是一個簡化的 CNI 外掛程式 cmdAdd 函式範例：

package main

// ... (套件引入)

func cmdAdd(args *skel.CmdArgs) error {
    // ... (解析 CNI 設定)

    // ... (建立 veth pair)

    // ... (設定 Pod 網路名稱空間)

    // ... (設定主機網路名稱空間)

    return nil
}

這個 cmdAdd 函式負責為 Pod 新增網路介面。它首先解析 CNI 設定，然後建立 veth pair，並分別在 Pod 和主機的網路名稱空間中設定網路介面。

  graph LR
    subgraph Pod 網路名稱空間
        A[Container Veth] --> B(Pod IP)
    end
    subgraph 主機網路名稱空間
        C[Host Veth] --> D(Bridge)
        D --> E(外部網路)
    end
    B ----> C

上圖再次展示 Pod 網路和主機網路的連線方式，方便讀者理解 CNI 的運作原理。

Kubernetes 網路元件：kube-controller-manager 與 Kubelet

  • kube-controller-manager： 管理叢集 CIDR 和 Service ClusterIP 範圍。
  • Kubelet： 管理 Pod 生命週期，並且 CNI 外掛程式互動，為 Pod 設定網路。

Cilium 網路策略範例

package main

// ... (套件引入)

func applyNetworkPolicy(ciliumClient *client.Client, namespace string, policy *v2.CiliumNetworkPolicy) error {
    // ... (建立或更新 CiliumNetworkPolicy)
    return nil
}

這個函式示範如何使用 Cilium 客戶端程式函式庫建立或更新 CiliumNetworkPolicy，實作更精細的網路控制。

這個範例程式碼展示瞭如何使用環境變數設定 Cilium 的網路策略，並透過 Kubernetes API 與 Cilium 互動。

我由淺入深地介紹了 Kubernetes CNI 的核心概念、架構和實戰應用，並提供程式碼範例和圖表説明，希望能幫助您更好地理解和應用 CNI 技術。在後續文章中，我將繼續探討 Kubernetes 的 Service 和 Ingress 等網路相關主題。


在現代網路應用程式開發中，Web 伺服器和資料函式庫的整合至關重要。我將運用 Go 語言的簡潔和高效，示範如何建構一個簡易的 Web 伺服器，並整合 PostgreSQL 資料函式庫的連線能力。這個伺服器將監聽 8080 埠，並提供三個主要的功能端點：`/`、`/healthz` 和 `/data`。

```go
package main

import (
	"database/sql"
	"fmt"
	"log"
	"net/http"

	_ "github.com/lib/pq" // PostgreSQL 驅動程式
)

var db *sql.DB

func main() {
    // 初始化資料函式庫連線
    connStr := "user=postgres password=password dbname=example sslmode=disable" // 請修改成你的資料函式庫連線資訊
    var err error
    db, err = sql.Open("postgres", connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 檢查資料函式庫連線
    err = db.Ping()
    if err != nil {
        log.Fatal(err)
    }

    // 設定路由
    http.HandleFunc("/", helloHandler)
    http.HandleFunc("/healthz", healthzHandler)
    http.HandleFunc("/data", dataHandler)

    // 啟動伺服器
    fmt.Println("伺服器執行於 :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "喵～") // 玄貓的招呼
}

func healthzHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "活力滿滿！") // 玄貓狀態良好
}

func dataHandler(w http.ResponseWriter, r *http.Request) {
    // 查詢資料函式庫版本
    rows, err := db.Query("SELECT version()")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer rows.Close()

    var version string
    for rows.Next() {
        err := rows.Scan(&version)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
    }

    fmt.Fprintln(w, "資料函式庫連線成功！版本：", version) // 玄貓回報資料函式庫版本
}

這段程式碼建構了一個簡易的 Web 伺服器，並整合了 PostgreSQL 資料函式庫的連線能力。伺服器監聽 8080 埠，並提供三個主要的功能端點：

  • /： 回應親切的 “喵～"，作為玄貓的獨特標誌。
  • /healthz： 回應 “活力滿滿！"，表明伺服器健康執行中。這個端點設計用於 Kubernetes 的健康檢查，確保服務的可用性。
  • /data： 嘗試連線 PostgreSQL 資料函式庫並查詢版本資訊，確認資料函式庫連線的有效性，並將資料函式庫版本資訊回傳給使用者端。

程式碼的核心邏輯在於使用 database/sql 標準函式庫與資料函式庫互動，並利用 net/http 標準函式庫處理 HTTP 請求與回應。_ "github.com/lib/pq" 則引入了必要的 PostgreSQL 驅動程式，讓程式碼可以與 PostgreSQL 資料函式庫溝通。

程式碼首先初始化資料函式庫連線，從程式碼中設定的連線字串讀取資料函式庫連線資訊。請記得將 connStr 的值修改成你自己的資料函式庫連線資訊。接著，使用 db.Ping() 檢查資料函式庫連線是否正常。

設定 HTTP 路由的部分，程式碼使用 http.HandleFunc() 將不同的 URL 路徑對應到不同的處理函式。例如，/ 路徑對應到 helloHandler 函式，/healthz 路徑對應到 healthzHandler 函式，而 /data 路徑則對應到 dataHandler 函式。

最後，程式碼使用 http.ListenAndServe() 啟動 HTTP 伺服器，開始監聽 8080 埠，等待使用者端請求。

這個範例程式碼簡潔易懂，適合初學者學習 Go 語言 Web 開發和資料函式庫整合。它示範瞭如何使用 Go 語言建立 Web 伺服器、連線 PostgreSQL 資料函式庫，以及處理 HTTP 請求。同時，/healthz 端點的設計也展現瞭如何在 Go 語言中實作 Kubernetes 健康檢查，這在實際應用中非常重要。

這個程式碼可以作為基礎，進一步擴充功能成更複雜的 Web 應用程式。例如，可以加入使用者認證、更豐富的資料函式庫操作、更複雜的 HTTP 端點邏輯等等。

我個人認為，這個程式碼範例的設計理念在於簡潔和實用。它避免了不必要的複雜性，專注於核心功能的示範，讓開發者可以快速掌握 Go 語言 Web 開發和資料函式庫整合的基礎知識。

透過這個簡單的 Web 伺服器範例，我們可以學習到 Go 語言如何與 PostgreSQL 資料函式庫互動，以及如何使用 net/http 標準函式庫建立路由和處理 HTTP 請求。這對於構建更複雜的 Web 應用程式是一個很好的起點。

這個程式碼片段展現了 Go 語言在 Web 開發和資料函式庫整合方面的優勢：簡潔、高效、易於理解。它提供了一個清晰的程式碼結構和簡潔的實作方式，方便開發者學習和應用。

package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"time"

	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"
)

func main() {
	// 建立與 Kubernetes API 伺服器的連線
	config, err := rest.InClusterConfig()
	if err != nil {
		log.Fatalf("無法建立叢集內部組態: %v", err)
	}

	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		log.Fatalf("無法建立 Kubernetes 使用者端: %v", err)
	}

	// 指定要查詢的 Pod 名稱和名稱空間
	podName := "你的Pod名稱"
	namespace := "你的名稱空間"

	// 取得 Pod 的詳細資訊
	pod, err := clientset.CoreV1().Pods(namespace).Get(context.TODO(), podName, metav1.GetOptions{})
	if err != nil {
		log.Fatalf("無法取得 Pod 資訊: %v", err)
	}

	// 顯示 Pod 的 DNS 設定
	fmt.Println("Pod DNS 設定：")
	fmt.Printf("DNS 策略： %s\n", pod.Spec.DNSPolicy)

	if pod.Spec.DNSConfig != nil {
		fmt.Println("DNS 詳細設定：")
		for _, nameserver := range pod.Spec.DNSConfig.Nameservers {
			fmt.Printf("- 網域名稱伺服器： %s\n", nameserver)
		}
		for _, search := range pod.Spec.DNSConfig.Searches {
			fmt.Printf("- 搜尋網域： %s\n", search)
		}
		if pod.Spec.DNSConfig.Options != nil {
			fmt.Println("DNS 選項：")
			for _, option := range pod.Spec.DNSConfig.Options {
				fmt.Printf("- 名稱： %s", option.Name)
				if option.Value != nil {
					fmt.Printf("，值： %s\n", *option.Value)
				} else {
					fmt.Println()
				}
			}
		}
	}

	// 測試 DNS 解析
	testDNSResolution(clientset, pod)
}

func testDNSResolution(clientset *kubernetes.Clientset, pod *v1.Pod) {
	fmt.Println("\n測試 DNS 解析：")

	resolver := net.Resolver{
		PreferGo: true,
		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
			// 使用 Pod 的 DNS 設定
			dnsIP := pod.Status.PodIP // 使用 Pod IP 作為 DNS 伺服器
			if pod.Spec.DNSPolicy == v1.DNSNone && pod.Spec.DNSConfig != nil && len(pod.Spec.DNSConfig.Nameservers) > 0 {
				dnsIP = pod.Spec.DNSConfig.Nameservers[0] // 使用自定義 DNS 伺服器
			}
			return net.DialTimeout(network, fmt.Sprintf("%s:53", dnsIP), 5*time.Second)
		},
	}

	testDomains := []string{"kubernetes.default.svc.cluster.local", "google.com"}

	for _, domain := range testDomains {
		ips, err := resolver.LookupIP(context.TODO(), "ip4", domain)
		if err != nil {
			fmt.Printf("解析 %s 失敗: %v\n", domain, err)
		} else {
			fmt.Printf("%s 解析結果：\n", domain)
			for _, ip := range ips {
				fmt.Printf("- %s\n", ip.String())
			}
		}
	}
}

這段 Go 程式碼示範如何在 Kubernetes 叢集內部取得 Pod 的 DNS 設定，並使用這些設定進行 DNS 解析。玄貓將帶您逐步拆解程式碼的邏輯與核心概念。

程式碼功能説明：

這段程式碼的主要功能是取得指定 Pod 的 DNS 設定，並測試使用該設定是否能正確解析網域名稱。它模擬了 Pod 內部進行 DNS 解析的過程，可以幫助開發者診斷 Pod 的 DNS 問題。

核心概念解析：

  • InClusterConfig()：用於在 Pod 內部建立 Kubernetes 使用者端組態。它會自動從 Pod 的環境變數中讀取必要的資訊，例如 API Server 地址和憑證。
  • NewForConfig()：根據組態建立 Kubernetes 使用者端。
  • Pods(namespace).Get()：取得指定名稱空間中指定名稱的 Pod 資訊。
  • DNSPolicy：Pod 的 DNS 策略，例如 “ClusterFirst”（優先使用叢集的 DNS）、“Default”（使用節點的 DNS）或 “None”（自定義 DNS）。
  • DNSConfig：Pod 的 DNS 詳細設定，例如網域名稱伺服器、搜尋網域和 DNS 選項。
  • net.Resolver：用於自定義 DNS 解析器。
  • LookupIP()：使用指定的 DNS 解析器解析網域名稱。

程式碼流程圖：

  graph LR
    B[B]
    C[C]
    A[建立 Kubernetes 使用者端] --> B{取得 Pod 資訊};
    B --> C{顯示 DNS 設定};
    C --> D[測試 DNS 解析];

程式碼時序圖：

  sequenceDiagram
    participant 程式碼
    participant Kubernetes API Server
    participant DNS 伺服器

    程式碼->>Kubernetes API Server: 請求 Pod 資訊
    activate Kubernetes API Server
    Kubernetes API Server-->>程式碼: 回應 Pod 資訊
    deactivate Kubernetes API Server

    程式碼->>DNS 伺服器: 請求解析網域名稱
    activate DNS 伺服器
    DNS 伺服器-->>程式碼: 回應解析結果
    deactivate DNS 伺服器

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: frontend-access-store
  namespace: store
spec:
  podSelector:
    matchLabels:
      app: store-api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          namespace: frontend
    ports:
    - protocol: TCP
      port: 8080

這個 YAML 檔案定義了一個 Kubernetes NetworkPolicy，用於控制 store 名稱空間中 store-api 應用程式的網路流量。 它的主要功能是限制只有 frontend 名稱空間中的 Pod 可以存取 store-api 的 8080 埠。

策略詳解：

  • name: frontend-access-store：NetworkPolicy 的名稱，清晰地表明瞭它的用途。
  • namespace: store：NetworkPolicy 所屬的名稱空間。
  • podSelector: 選擇套用此策略的 Pod。 這裡使用 matchLabels 選擇帶有 app: store-api 標籤的 Pod。
  • policyTypes: - Ingress：指定此策略只控制進入 Pod 的流量。
  • ingress: 定義允許的入口流量規則。
    • from: 指定允許流量的來源。
      • namespaceSelector: 使用 matchLabels 選擇 namespace: frontend 的名稱空間作為允許的流量來源。
    • ports: 指定允許的埠。
      • protocol: TCP: 指定使用的協定為 TCP。
      • port: 8080: 指定允許存取的埠號為 8080。

策略圖示：

  graph LR
    subgraph frontend 名稱空間
        A[Frontend Pod] --> B(NetworkPolicy)
    end
    subgraph store 名稱空間
        B --> C[Store-api Pod port 8080]
    end
    D[其他名稱空間] --> B

圖中清晰地展示了 NetworkPolicy 如何允許 frontend 名稱空間的 Pod 存取 store-api，同時阻擋來自其他名稱空間的流量。

透過以上設定，我們可以有效地隔離 store-api 應用程式，只允許來自 frontend 名稱空間的流量存取，提升了應用程式的安全性。 這也是微服務架構中常見的網路安全策略，可以有效地限制服務之間的存取，降低潛在的安全風險。

這個範例結合 Go 程式碼和 NetworkPolicy 設定，展現瞭如何在 Kubernetes 中實作更安全的網路存取控制。 讀者可以根據自身需求調整 NetworkPolicy 的規則，例如更精細的標籤選擇器、IP 範圍限制等，開發更安全的 Kubernetes 應用程式環境。

解析 Kubernetes 服務發現：從 Endpoints 到 Endpoints Slices

在 Kubernetes 架構中，服務發現扮演著連結服務與 Pod 的關鍵角色，如同導航系統引導流量到正確目的地。為了實作高效的服務發現，Kubernetes 提供了 Endpoints 和 Endpoints Slices 兩種機制。我將深入剖析它們的運作方式，並探討如何提升服務發現的效能和可擴充性。

Endpoints：奠定服務發現的基礎

Endpoints 是 Kubernetes 早期版本採用的服務發現機制。它如同一個集中式的地址簿，記錄了所有屬於 Service 的 Pod 的 IP 地址和連線埠。然而，在大規模叢集中，這種集中式管理方式會遇到效能瓶頸。每次 Pod 地址變更，都需更新整個 Endpoints 物件，並同步到所有 kube-proxy，造成不必要的負擔。

Endpoints Slices：邁向高效能與可擴充性

為了突破 Endpoints 的限制，Kubernetes 引入了 Endpoints Slices。它將 Pod 地址分散到多個 EndpointSlice 中，每個 Slice 只包含一部分 Pod 地址。這種分散式管理方式，如同將地址簿拆分成多個分冊，當 Pod 地址變更時，只需更新相關的 EndpointSlice，大幅降低 kube-proxy 的同步負擔，提升叢集效能和可擴充性。

您可以使用 kubectl get endpointslice 命令檢視叢集中的 EndpointSlices，並使用 kubectl describe endpointslice <endpointslice-name> 檢視特定 EndpointSlice 的詳細資訊，例如 Pod 的 IP 地址、主機名和所在節點。這些資訊對於診斷網路問題至關重要。

  graph LR
    Endpoints_and_Endpoints_Slices[Endpoints_and_Endpoints_Slices]
    Pods[Pods]
    Service[Service]
    Service --> Endpoints_and_Endpoints_Slices
    Endpoints_and_Endpoints_Slices --> Pods

圖示説明: 上圖展現了 Service、Endpoints/Endpoints Slices 和 Pods 之間的關係。Service 透過 Endpoints 或 Endpoints Slices 找到對應的 Pods。

Go Web 伺服器範例：揭示主機名與 Pod IP

以下 Go Web 伺服器範例示範如何顯示主機名和 Pod IP：

package main

import (
	"fmt"
	"log"
	"net"
	"net/http"
	"os"
)

func main() {
	http.HandleFunc("/", handler)
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	log.Printf("Listening on port %s", port)
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
}

func handler(w http.ResponseWriter, r *http.Request) {
	hostname, err := os.Hostname()
	if err != nil {
		hostname = "unknown"
	}

	podIP := getPodIP()

	fmt.Fprintf(w, "Hostname: %s\n", hostname)
	fmt.Fprintf(w, "Pod IP: %s\n", podIP)
}

func getPodIP() string {
	addrs, err := net.InterfaceAddrs()
	if err != nil {
		return "unknown"
	}

	for _, addr := range addrs {
		ipnet, ok := addr.(*net.IPNet)
		if !ok {
			continue
		}

		if ipnet.IP.IsLoopback() {
			continue
		}

		if ipnet.IP.To4() != nil {
			return ipnet.IP.String()
		}
	}

	return "unknown"
}

這段程式碼建立一個 HTTP 伺服器，監聽環境變數 PORT 指定的連線埠，預設為 8080。handler 函式處理 HTTP 請求，並回傳主機名和 Pod IP。getPodIP 函式則用於取得 Pod 的 IP 地址。

Kubernetes Deployment 與 Service 設定

以下 YAML 檔案定義了 Deployment 和 Service：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: demo
  template:
    metadata:
      labels:
        app: demo
    spec:
      containers:
      - name: web
        image: ghcr.io/blackcat-dev/go-web-server:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 200m
            memory: 256Mi
---
apiVersion: v1
kind: Service
metadata:
  name: clusterip-service
spec:
  selector:
    app: demo
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080
  type: ClusterIP

Deployment 建立了三個名為 app 的 Pod，每個 Pod 執行 Go Web 伺服器，監聽 8080 連線埠。Service 名為 clusterip-service，型別為 ClusterIP，將流量導向所有帶有 app: demo 標籤的 Pod 的 8080 連線埠。

Kubernetes Service 型別：NodePort 與 ClusterIP

Kubernetes 提供多種 Service 型別，NodePort 和 ClusterIP 最為常用。

NodePort 在每個節點上開啟一個靜態連線埠，外部應用程式可透過節點 IP 和 NodePort 存取服務。

ClusterIP 提供內部負載平衡器，僅供叢集內部存取。

  graph LR
    Access[Access]
    Client[Client]
    ClusterIP[ClusterIP]
    External[External]
    Internal[Internal]
    NodePort[NodePort]
    Client --External Access--> NodePort --> Pods
    Client --Internal Access--> ClusterIP --> Pods

圖示説明: 上圖比較 NodePort 和 ClusterIP 的差異。NodePort 允許外部存取，ClusterIP 僅限叢集內部存取。

Headless Service 與 DNS 解析

package main

import (
	"fmt"
	"net"
	"os"
)

func main() {
	ips, err := net.LookupIP("headless-service.default.svc.cluster.local")
	if err != nil {
		fmt.Println("DNS 查詢失敗:", err)
		os.Exit(1)
	}

	fmt.Println("解析到的 IP 地址:")
	for _, ip := range ips {
		fmt.Println(ip)
	}
}

這段 Go 程式碼示範如何解析 Kubernetes headless service 的 DNS 記錄。Headless service 不分配 ClusterIP，而是直接將服務名稱解析為後端 Pod 的 IP 地址列表，方便服務發現和直接連線。

ClusterIP 與 NodePort 深入解析

ClusterIP 是 Kubernetes 預設服務型別，提供叢集內部穩定的 IP 地址，適用於不需要外部存取的應用程式，例如內部資料函式庫或後端 API。NodePort 則在每個節點開啟靜態連線埠，允許外部應用程式透過節點 IP 和連線埠存取服務，適用於 Web 應用程式或 API 閘道器。

選擇 ClusterIP 或 NodePort 取決於是否需要外部存取、效能需求和安全性考量。建議使用名稱空間、設定資源限制和監控服務狀態等最佳實踐。

透過 Endpoints 和 Endpoints Slices，Kubernetes 建構了高效與可擴充的服務發現機制，確保應用程式在叢集中的穩定運作。不同型別的 Service 提供不同的存取方式，滿足各種應用程式場景的需求。未來我將探討 LoadBalancer 和 Ingress 等更進階的服務型別，以及它們如何提供更強大的負載平衡和流量管理功能。

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	http.HandleFunc("/host", func(w http.ResponseWriter, r *http.Request) {
		nodeName := os.Getenv("NODE_NAME")
		podIP := os.Getenv("POD_IP")
		response := fmt.Sprintf("節點名稱: %s\nPod IP: %s\n", nodeName, podIP)
		_, err := w.Write([]byte(response))
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	})

	http.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	})

	port := "8080"
	if fromEnv := os.Getenv("PORT"); fromEnv != "" {
		port = fromEnv
	}

	log.Printf("伺服器啟動，監聽埠號: %s\n", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

這段 Go 程式碼建構了一個精簡的 HTTP 伺服器，用於展示 Kubernetes 服務的運作機制，特別是在 LoadBalancer 型別的服務中。伺服器監聽兩個重要端點：/host 和 /healthz。/host 端點會回傳當前 Pod 所在的節點名稱和 Pod 的 IP 地址，這些資訊由 Kubernetes 自動注入到環境變數 NODE_NAME 和 POD_IP 中。/healthz 端點則回應 200 OK 狀態碼，作為 Kubernetes 的健康檢查指標，確保服務正常運作。伺服器預設監聽 8080 埠，但可以透過設定環境變數 PORT 來指定不同的埠號，提升了佈署的彈性。

  graph LR
    B[B]
    A[使用者端請求] --> B{LoadBalancer};
    B --> C[節點 1];
    B --> D[節點 2];
    C --> E[Pod 1];
    D --> F[Pod 2];

上圖展示了 LoadBalancer 服務如何將外部流量分發到後端 Pod。使用者端請求會先到達 LoadBalancer，然後 LoadBalancer 將流量分發到不同節點上的 Pod，實作負載平衡和高用性。在實際應用中，LoadBalancer 服務通常會搭配 Ingress Controller，例如 Nginx Ingress Controller 或 Traefik，來實作更進階的路由和流量管理功能。對於裸機環境，MetalLB 則是一個常用的 LoadBalancer 解決方案。

package main

import (
	"context"
	"fmt"
	"net/http"
	"time"

	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/rest"
)

func main() {
	// 建立 Kubernetes API Client
	config, err := rest.InClusterConfig()
	if err != nil {
		panic(err.Error())
	}
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		panic(err.Error())
	}

	// Pod 資訊
	podName := "example-pod"
	namespace := "default"

	// 執行健康檢查
	for {
		pod, err := clientset.CoreV1().Pods(namespace).Get(context.TODO(), podName, kubernetes.GetOptions{})
		if err != nil {
			fmt.Printf("無法取得 Pod 狀態: %s\n", err.Error())
			time.Sleep(10 * time.Second)
			continue
		}

		if pod.Status.Phase == "Running" {
			resp, err := http.Get(fmt.Sprintf("http://%s:8080/healthz", pod.Status.PodIP))
			if err != nil {
				fmt.Printf("HTTP 檢查失敗: %s\n", err.Error())
				time.Sleep(10 * time.Second)
				continue
			}
			defer resp.Body.Close()

			if resp.StatusCode == http.StatusOK {
				fmt.Println("Pod 健康檢查透過")
				break // 檢查透過，跳出迴圈
			} else {
				fmt.Printf("HTTP 檢查傳回非 200 狀態碼: %d\n", resp.StatusCode)
				time.Sleep(10 * time.Second)
			}
		} else {
			fmt.Printf("Pod 狀態非 Running: %s\n", pod.Status.Phase)
			time.Sleep(10 * time.Second)
		}
	}
}

這段 Go 程式碼示範瞭如何在 Kubernetes 叢集中執行 Pod 的健康檢查。它利用 Kubernetes Go Client 函式庫與 API Server 互動，結合 Pod 狀態檢查和 HTTP 檢查。程式碼會定期檢查目標 Pod 的狀態，如果 Pod 狀態為 Running，則會對 Pod 的 /healthz 路徑傳送 HTTP GET 請求。如果 HTTP 檢查傳回 200 狀態碼，則表示 Pod 健康，程式會跳出迴圈；否則，程式會列印錯誤訊息並繼續檢查。

  graph LR
    D[D]
    E[E]
    F[F]
    A[使用者端] --> B(NodePort);
    subgraph Kubernetes 叢集
        B --> C[ClusterIP 服務];
        C --> D{Pod 1};
        C --> E{Pod 2};
        C --> F{Pod 3};
    end

這個圖表展示了 NodePort 服務如何將外部流量轉發到 ClusterIP 服務，再由 ClusterIP 服務負載平衡到後端 Pod。NodePort 服務會在每個節點上開啟一個特定的埠號，外部流量透過這個埠號就能存取到叢集內的服務。

深入 Kubernetes 的服務發現與負載平衡機制，探討 ClusterIP、NodePort 和 LoadBalancer 等服務型別，並提供 Go 語言程式碼範例，展示如何與這些服務互動、執行健康檢查以及整合 MetalLB 和 Ingress 等進階用法。透過理解這些服務型別，開發者可以更有效地管理 Kubernetes 應用程式的流量、提升應用程式的可靠性和擴充性，並建構更穩健的雲原生應用程式。

package main

import (
	"context"
	"fmt"
	"net/http"
	"os"
	"time"

	"github.com/gorilla/mux"
)

func main() {
	// 初始化路由器
	router := mux.NewRouter()

	// 設定路由規則
	router.HandleFunc("/", homeHandler)
	router.HandleFunc("/healthz", healthCheckHandler)

	// 建立 HTTP 伺服器
	server := &http.Server{
		Handler:      router,
		Addr:         ":8080",
		WriteTimeout: 15 * time.Second,
		ReadTimeout:  15 * time.Second,
	}

	// 啟動伺服器
	fmt.Println("伺服器正在監聽 8080 埠")
	if err := server.ListenAndServe(); err != nil {
		fmt.Fprintln(os.Stderr, "啟動伺服器失敗:", err)
		os.Exit(1)
	}
}

// 首頁處理函式
func homeHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "歡迎來到玄貓的網站！")
}

// 健康檢查處理函式
func healthCheckHandler(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusOK)
}

這段 Go 程式碼建立了一個簡單的 HTTP 伺服器，使用了 Gorilla Mux 路由器來處理不同路徑的 HTTP 請求。伺服器監聽 8080 埠，並設定了讀寫逾時為 15 秒，以防止請求處理時間過長。

homeHandler 函式處理根路徑 / 的請求，並回傳 “歡迎來到玄貓的網站！"。healthCheckHandler 函式處理 /healthz 路徑的請求，主要用於 Kubernetes 的健康檢查，回傳 200 OK 狀態碼。

  graph LR
    healthz[healthz]
    A[使用者端請求] --> B{路由器};
    B -- / --> C[homeHandler];
    B -- /healthz --> D[healthCheckHandler];
    C --> E[歡迎訊息];
    D --> F[200 OK];

上圖展示了伺服器如何處理不同路徑的請求，以及各個元件之間的關係。

package main

import (
	"context"
	"fmt"
	"net/http"
	"os/exec"
	"strconv"
	"strings"
	"time"

    // ... other imports
)


// 執行 Linkerd 安裝前檢查
func linkerdCheck(ctx context.Context) error {
	// ... 執行 linkerd check 命令 ...
    return nil // Placeholder
}

// 將 Linkerd proxy 注入到 Kubernetes 佈署
func injectLinkerdProxy(ctx context.Context, deploymentFile string) error {
	// ... 執行 linkerd inject 命令 ...
    return nil // Placeholder
}

// 顯示 Linkerd 統計資訊
func displayLinkerdStats(ctx context.Context, namespace string) error {
	// ... 執行 linkerd stat 命令 ...
    return nil // Placeholder
}

// 模擬 HTTP 流量
func simulateTraffic(ctx context.Context, serviceURL string, requests int, delay time.Duration) error {
	// ... 傳送 HTTP 請求 ...
    return nil // Placeholder
}

這段程式碼定義了幾個與 Linkerd Service Mesh 相關的函式。linkerdCheck 函式執行 Linkerd 的 pre-install 檢查，確保 Kubernetes 叢集環境符合 Linkerd 的安裝需求。injectLinkerdProxy 函式將 Linkerd 的 sidecar proxy 注入到應用程式的 Pod 中，以實作流量管理和 mTLS 加密。displayLinkerdStats 函式顯示 Linkerd 的統計資訊，方便監控服務的執行狀態。simulateTraffic 函式模擬流量，用於測試服務的效能和穩定性。

  graph LR
    A[應用程式 Pod] --> B[Linkerd Proxy Sidecar];
    B --> C[目標服務];
    D[Linkerd 控制平面] --> B;

上圖展示了 Linkerd Proxy Sidecar 如何攔截應用程式 Pod 的流量，並且 Linkerd 控制平面互動，實作服務網格的核心功能。

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/ec2"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"

    // ... other imports
)

func main() {
	// ... (其他程式碼)

	// 建立 Kubernetes 客戶端
	kubeconfig := os.Getenv("KUBECONFIG")
	config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
	if err != nil {
		// 使用 log.Fatalf 輸出錯誤訊息並結束程式
		fmt.Fprintf(os.Stderr, "建立 Kubernetes 設定失敗: %s\n", err)
		os.Exit(1)
	}

	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		fmt.Fprintf(os.Stderr, "建立 Kubernetes 客戶端失敗: %s\n", err)
		os.Exit(1)
	}

	// ... 後續操作 Kubernetes 資源的程式碼 ...
}

這段程式碼示範瞭如何在 Go 程式中建立 Kubernetes 客戶端。它首先從環境變數 KUBECONFIG 中取得 Kubernetes 設定檔路徑，然後使用 clientcmd.BuildConfigFromFlags 函式建立 Kubernetes 設定。接著，使用 kubernetes.NewForConfig 函式建立 Kubernetes 客戶端 clientset，用於後續與 Kubernetes 叢集的互動。如果建立設定或客戶端過程中出現錯誤，程式將會輸出錯誤訊息並結束。

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/ec2"
)

func main() {
	// 設定 AWS 區域
	awsRegion := os.Getenv("AWS_REGION")
	if awsRegion == "" {
		awsRegion = "us-east-1" // 預設區域
	}

	// 載入 AWS 設定
	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(awsRegion))
	if err != nil {
		fmt.Fprintf(os.Stderr, "無法載入 AWS 設定: %v\n", err)
		os.Exit(1)
	}

	// 建立 EC2 客戶端
	ec2Client := ec2.NewFromConfig(cfg)

	// 取得 VPC 資訊
	vpcs, err := ec2Client.DescribeVpcs(context.TODO(), &ec2.DescribeVpcsInput{})
	if err != nil {
		fmt.Fprintf(os.Stderr, "無法取得 VPC 資訊: %v\n", err)
		os.Exit(1)
	}

	// 顯示 VPC 資訊
	fmt.Println("VPC 清單:")
	for _, vpc := range vpcs.Vpcs {
		fmt.Printf("  VPC ID: %s\n", *vpc.VpcId)
		fmt.Printf("  CIDR 區塊: %s\n", *vpc.CidrBlock)
		fmt.Printf("  是否為預設 VPC: %t\n", vpc.IsDefault)
		fmt.Printf("  狀態: %s\n", vpc.State)
		fmt.Println("------")
	}
}

這段 Go 程式碼示範瞭如何使用 AWS SDK for Go 來取得和顯示所有 VPC 的資訊。程式碼首先設定 AWS 區域，如果環境變數 AWS_REGION 未設定，則使用 us-east-1 作為預設區域。接著，程式碼載入 AWS 設定，並建立 EC2 客戶端。然後，使用 DescribeVpcs API 取得所有 VPC 的資訊，最後將 VPC 的 ID、CIDR 區塊、是否為預設 VPC 以及狀態等資訊列印預到螢幕上。

這篇文章示範瞭如何使用 Go 語言開發 Web 應用程式，並整合 Linkerd 和 AWS 等雲原生技術。同時，也展示瞭如何使用來輔助説明技術架構和流程。透過這些範例，希望能幫助讀者更深入地理解 Go 語言在雲原生環境下的應用。

地理位置與網路基礎建設：區域與可用區

身為一個技術工作者，我時常在全球各地建置雲端架構。GCP 的網路設計一直讓我印象深刻，它巧妙地結合了全球覆寫和區域彈性。這篇文章將探討 GCP 網路架構中兩個關鍵概念：區域和可用區，並闡述它們如何共同構築 GCP 的全球基礎設施。

GCP 的網路遍佈全球，由多個區域、可用區和網路邊緣位置組成。區域是指獨立的地理區域，每個區域都包含多個可用區。可用區通常代表一個資料中心，可視為一個故障網域。這樣的設計提供了高用性和容錯能力。

  graph LR
    subgraph 全球
        A[區域 1] --> B(可用區 A)
        A --> C(可用區 B)
        D[區域 2] --> E(可用區 C)
        D --> F(可用區 D)
    end
    全球 -- 網路連線 --> 網際網路

上圖展示了區域和可用區之間的關係。多個可用區組成一個區域，而多個區域則構成了 GCP 的全球網路。這樣的設計允許我們將應用程式佈署在不同的可用區，實作高用性。即使一個可用區發生故障，其他可用區的應用程式仍然可以正常運作。

VPC 與子網路：開發專屬網路空間

虛擬私有雲 (VPC) 是 GCP 中另一個重要的網路概念。它是一個由我們自行定義的網路空間，提供與實體網路類別似的功能，例如 IP 位址範圍、路由表和防火牆規則。在 VPC 中，我們可以建立子網路，將 VPC 劃分為更小的網路區塊，以便更精細地管理網路資源。

  graph LR
    A[VPC] --> B(子網路 1);
    A --> C(子網路 2);
    B --> D[虛擬機器 1];
    C --> E[虛擬機器 2];

上圖展示了 VPC 和子網路之間的關係。VPC 包含多個子網路，每個子網路可以容納多個虛擬機器或其他網路資源。子網路可以位於不同的區域或可用區，方便我們根據需求佈署資源。

區域、可用區、VPC 與子網路的協同運作

區域、可用區、VPC 和子網路共同構成了 GCP 的網路架構。它們之間的關係可以用以下圖表表示：

  graph LR
    A[區域] --> B(可用區 1);
    A --> C(可用區 2);
    B --> D[VPC];
    C --> D;
    D --> E(子網路 1);
    D --> F(子網路 2);

上圖清晰地展示了區域、可用區、VPC 和子網路之間的層級關係。一個區域包含多個可用區，一個 VPC 可以跨越多個可用區，而 VPC 內又包含多個子網路。這樣的設計提供了高度的靈活性，讓我們可以根據應用程式的需求，選擇最合適的網路組態。

在設計 GCP 網路架構時，我通常會考慮以下幾個因素：

  • 高用性： 將應用程式佈署在不同的可用區，避免單點故障。
  • 安全性： 使用防火牆規則和網路 ACL 控制網路流量，保護應用程式安全。
  • 效能： 選擇合適的區域和子網路，降低網路延遲。
  • 成本： 根據實際需求選擇合適的網路資源，避免浪費。

透過理解區域、可用區、VPC 和子網路的概念，我們可以更好地設計和管理 GCP 網路架構，構建高用性、高安全性、高效能的雲端應用程式。這也是我在多年實踐中積累的寶貴經驗。

解析 GCP 網路核心元件：區域、可用區、VPC 與子網路

身為一個技術工作者，我經常需要處理雲端架構的設計與實作。在 Google Cloud Platform (GCP) 上，網路架構的規劃至關重要。我將深入剖析 GCP 網路幾個核心元件：區域、可用區、虛擬私有雲 (VPC) 和子網路。

區域與可用區：地理位置與容錯能力

GCP 的資源佈署在全球各個區域。每個區域都包含多個可用區，這些可用區是相互隔離但又低延遲連線的基礎設施。選擇正確的區域和可用區對於應用程式的效能和容錯能力至關重要。

  flowchart LR
    -[-]
    subgraph 全球
        subgraph 區域 A
            A1[可用區 1]
            A2[可用區 2]
            A3[可用區 3]
        end
        subgraph 區域 B
            B1[可用區 1]
            B2[可用區 2]
        end
    end
    A1 --- 網路連線 --- B1
    A2 --- 網路連線 --- B2
    A3 --- 網路連線 --- B1

圖表説明: 這個圖表展示了 GCP 區域和可用區的關係。區域 A 有三個可用區，而區域 B 有兩個。不同區域之間透過網路連線。

我個人的經驗是，在設計分散式系統時，我會優先考慮將資源佈署在多個可用區，以提高應用程式的可用性。即使一個可用區發生故障，其他可用區的資源仍然可以繼續運作。

VPC 與子網路：邏輯隔離與網路管理

VPC 是一個由您定義的虛擬網路，它為 GCP 專案中的資源提供連線。您可以將 VPC 劃分為多個子網路，每個子網路都有自己的 IP 位址範圍。子網路讓您可以更精細地控制網路流量，並將資源邏輯隔離。

  graph LR
    subgraph VPC
        subnet1[子網路 1]
        subnet2[子網路 2]
        subnet3[子網路 3]
    end

圖表説明: 這個圖表展示了 VPC 和子網路的關係。一個 VPC 可以包含多個子網路。

我發現，使用子網路可以更有效地管理網路資源。例如，您可以將前端應用程式佈署在一個子網路中，而後端資料函式庫佈署在另一個子網路中，並透過防火牆規則控制它們之間的流量。

GCP 防火牆與負載平衡：安全與效能兼顧

GCP 提供了防火牆和負載平衡等服務，以確保應用程式的安全性和高效能。

防火牆規則：精細控制網路存取

GCP 防火牆規則允許您根據預先定義的規則允許或拒絕網路連線。這些規則可以應用於虛擬機器執行個體、子網路或整個 VPC。

雲端負載平衡：分散流量提升可靠性

Google Cloud Load Balancer (GCLB) 可以將流量分發到多個虛擬機器執行個體，提高應用程式的可用性和容錯能力。

  graph LR
    使用者 --> GCLB
    GCLB --> 執行個體1
    GCLB --> 執行個體2
    GCLB --> 執行個體3

圖表説明: 這個圖表展示了 GCLB 如何將流量分發到多個執行個體。

GKE 網路：容器化應用程式的網路管理

Google Kubernetes Engine (GKE) 是 GCP 上的託管式 Kubernetes 服務。GKE 網路與 GCP 網路緊密整合，讓您可以輕鬆地管理容器化應用程式的網路。

GKE 提供了多種網路模式，您可以根據應用程式的需求選擇最適合的模式。

Azure 虛擬網路深度解析：子網、路由與 Go 程式碼實作

Azure 虛擬網路 (VNet) 是 Azure 雲端平台的核心網路服務。我將探討 VNet 的關鍵概念，包括子網、路由表以及如何使用 Go 語言進行網路組態。

VNet 基礎：您的雲端私有網路

VNet 就像您在雲端中的私有網路空間，與其他 Azure 客戶的網路隔離。您可以使用 VNet 連線您的 Azure 資源，例如虛擬機器和 Azure Kubernetes Service (AKS) 叢集。

子網：組織與管理您的 VNet

子網是 VNet 的一部分，具有自己的 IP 位址範圍。您可以使用子網將資源分組，並對每個組應用不同的網路策略。

路由表：控制網路流量走向

路由表決定了網路流量如何進出子網。每個子網都關聯一個路由表，其中包含一系列規則，用於指定流量的目的地和下一跳。

Go 語言實踐：網路地址與路由操作

以下 Go 程式碼示範如何使用 net 標準函式庫操作網路地址和子網：

package main

import (
	"fmt"
	"net"
)

func main() {
	_, ipv4Net, _ := net.ParseCIDR("192.168.0.0/16")

	subnet1, _ := ipv4Net.Subnet(24, 0)
	subnet2, _ := ipv4Net.Subnet(24, 1)

	fmt.Println("VNet CIDR:", ipv4Net)
	fmt.Println("Subnet 1:", subnet1)
	fmt.Println("Subnet 2:", subnet2)


	routeTable := map[string]string{
		subnet1.String(): "Next-hop: 虛擬裝置",
		subnet2.String(): "Next-hop: 虛擬裝置",
		"0.0.0.0/0":      "Next-hop: 網際網路",
	}

	fmt.Println("\n路由表:")
	for destination, nextHop := range routeTable {
		fmt.Println(destination, "=>", nextHop)
	}
}

這段程式碼解析 VNet 的 CIDR 塊，並使用 Subnet 函式建立兩個子網。接著，它示範如何建立路由表，將特定流量導向不同的下一跳地址。

  graph LR
    subgraph VNet
        subgraph 子網路 1
            A[虛擬機器] --> B(虛擬裝置)
        end
        subgraph 子網路 2
            C[AKS 叢集] --> D(虛擬裝置)
        end
    end
    VNet --> 網際網路
    VNet --> 內部佈署

圖表説明: 此圖表展示了 VNet、子網以及它們與網際網路和內部佈署網路的連線。

// 使用服務標籤設定路由規則
func configureRouteWithServiceTag(routeTable *network.RouteTable, subnet *network.Subnet, routeName string) error {
	destinationAddressPrefix := "SQL.EastUs" 
	nextHopType := network.RouteNextHopTypeInternet

	route := network.Route{
		Name: &routeName,
		RoutePropertiesFormat: &network.RoutePropertiesFormat{
			AddressPrefix:    &destinationAddressPrefix,
			NextHopType:      nextHopType,
			DestinationSubnet: subnet.Name,
		},
	}

	_, err := routeTable.CreateOrUpdate(context.Background(), routeName, route)
	return err
}

這段程式碼設定一條使用服務標籤的路由規則，將前往 SQL.EastUs 的流量導向指定的子網路。它使用 Azure SDK for Go 的 network 套件來操作網路資源。

透過深入理解 Azure VNet、子網和路由表，並結合 Go 語言的程式碼實踐，您可以更有效地管理和控制您的雲端網路環境。

package network

import (
	"context"
	"fmt"
	"github.com/Azure/azure-sdk-for-go/services/network/mgmt/2019-09-01/network"
	"github.com/Azure/go-autorest/autorest/to"
)


// 建立指向網際網路的路由規則
func createInternetRoute(routeTableName, routeName, addressPrefix, nextHopIPAddress string, routeTable network.RouteTable) error {

	nextHopType := network.RouteNextHopTypeInternet
	route := network.Route{
		Name: to.StringPtr(routeName),
		RoutePropertiesFormat: &network.RoutePropertiesFormat{
			AddressPrefix:    to.StringPtr(addressPrefix),
			NextHopType:      nextHopType,
			NextHopIPAddress: to.StringPtr(nextHopIPAddress),
		},
	}

	ctx := context.Background()
	_, err := routesClient.CreateOrUpdate(ctx, resourceGroupName, routeTableName, routeName, route)
	if err != nil {
		return fmt.Errorf("建立路由規則失敗: %w", err)
	}
	return nil
}

這個函式用於建立一條指向網際網路的路由規則。它接收路由表名稱、路由規則名稱、地址字首和下一跳 IP 地址作為引數。函式內部設定 nextHopType 為 network.RouteNextHopTypeInternet，表示下一跳型別是網際網路。接著，它建立一個 network.Route 結構體，並設定路由規則的名稱、地址字首、下一跳型別和下一跳 IP 地址。最後，它呼叫 routesClient.CreateOrUpdate 方法將路由規則新增到指定的路由表中。

// 建立靜態公開 IP 地址
func createStaticPublicIP(ipName, resourceGroupName, location string) (network.PublicIPAddress, error) {
	ipConfig := network.PublicIPAddress{
		Name:     to.StringPtr(ipName),
		Location: to.StringPtr(location),
		PublicIPAddressPropertiesFormat: &network.PublicIPAddressPropertiesFormat{
			PublicIPAllocationMethod: network.Static,
			DNSSettings: &network.PublicIPAddressDNSSettings{
				DomainNameLabel: to.StringPtr(ipName),
			},
		},
	}

	ctx := context.Background()
	ip, err := publicIPClient.CreateOrUpdate(ctx, resourceGroupName, ipName, ipConfig)
	if err != nil {
		return network.PublicIPAddress{}, fmt.Errorf("建立靜態公開 IP 失敗: %w", err)
	}

	err = ip.WaitForCompletionRef(ctx, publicIPClient.Client)
	if err != nil {
		return network.PublicIPAddress{}, fmt.Errorf("等待靜態公開 IP 建立完成失敗: %w", err)
	}

	createdIP, err := publicIPClient.Get(ctx, resourceGroupName, ipName, "")
	if err != nil {
		return network.PublicIPAddress{}, fmt.Errorf("取得靜態公開 IP 失敗: %w", err)
	}

	return createdIP, nil
}

這個函式示範如何使用 Azure SDK for Go 建立一個靜態公開 IP 地址。它接收 IP 名稱、資源群組名稱和位置作為引數。函式內部建立一個 network.PublicIPAddress 結構體，設定 IP 名稱、資源群組、位置，以及 PublicIPAllocationMethod 為 network.Static，表示建立的是靜態 IP。同時，它也設定了 DNS 標籤。接著，它呼叫 publicIPClient.CreateOrUpdate 方法來建立或更新 IP 地址，並使用 WaitForCompletionRef 確保操作完成。最後，使用 publicIPClient.Get 方法取得建立好的 IP 地址資訊並傳回。

  graph LR
    C[C]
    No[No]
    Yes[Yes]
    A[建立 PublicIPAddress 結構體] --> B[呼叫 CreateOrUpdate];
    B --> C{建立成功?};
    C -- Yes --> D[等待操作完成];
    D --> E[取得 IP 地址資訊];
    E --> F[傳回 IP 地址];
    C -- No --> G[傳回錯誤];

這張流程圖展示了 createStaticPublicIP 函式的執行流程。首先，函式建立一個 PublicIPAddress 結構體，然後呼叫 CreateOrUpdate 方法。如果建立成功，則等待操作完成，並取得 IP 地址資訊後傳回。如果建立失敗，則傳回錯誤。

在 Azure 中設定網路組態時，必須考慮以下幾點：

  • 網路安全群組 (NSG)： 設定 NSG 規則時，應遵循最小許可權原則，僅允許必要的流量進出資源。避免規則衝突，並根據需求設定入站和出站規則。
  • 負載平衡器： 選擇適合應用程式需求的負載平衡器型別。標準負載平衡器適用於第四層負載平衡，而應用程式閘道適用於第七層負載平衡，並提供 WAF 和入口控制器功能。
  • 路由設定： 正確設定路由規則，確保流量可以正確導向目標資源。使用服務標籤可以簡化路由設定，並提高程式碼的可讀性和可維護性。

透過理解這些概念並結合程式碼範例，可以更有效地在 Azure 上構建和管理網路架構。

建構高用性 Kubernetes 叢集如同構建一座堅固的堡壘，需要多方位的考量和策略。網路、資源和安全如同三大支柱，支撐著整個叢集的穩定執行。本文將探討如何構建高用性 Kubernetes 叢集，並分享我在實戰中積累的經驗和洞察。

  graph LR
    C[C]
    IPv4[IPv4]
    IPv6[IPv6]
    A[開發堅不可摧的Kubernetes堡壘：高用性叢集構建策略] --> B(網路根本)
    B --> C{IP協定版本策略}
    C -- IPv4 --> D[IPv4單兵作戰]
    C -- IPv6 --> E[IPv6單騎突進]
    C -- 雙堆積疊 --> F[IPv4/IPv6雙劍合璧]
    B --> G(服務發現：精準定位元)
    G --> H[DNS定址]
    G --> I[服務網格導覽]
    B --> J(負載平衡：分流壓力)
    J --> K[kube-proxy流量管理]
    J --> L[Ingress控制器外部連線]
    A --> M(資源調配：彈性伸縮)
    M --> N[CPU與記憶體：效能保障]
    M --> O[儲存：資料根本]
    A --> P(安全防護：固若金湯)
    P --> Q[網路策略：安全屏障]
    P --> R[Pod安全：最小攻擊面]

這張圖表概述了建構高用性 Kubernetes 叢集的關鍵要素，我將其歸納為網路根本、資源調配和安全防護三大支柱。網路根本方面，IP 協定版本策略是首要考慮的，選項包括 IPv4、IPv6 或雙堆積疊。服務發現機制如同精準定位元，引導流量到正確的服務，DNS 定址和服務網格是兩種主要的實作方式。負載平衡則負責分流壓力，kube-proxy 負責內部流量管理，Ingress 控制器則管理外部連線。資源調配如同彈性伸縮，CPU 和記憶體是效能保障的關鍵，儲存則是資料根本。安全防護如同固若金湯，網路策略構建安全屏障，Pod 安全則將攻擊面降至最低。

在構建大規模 Kubernetes 平台的過程中，網路層面的挑戰總是讓我印象深刻。從 Kubernetes 的早期版本到現在，網路功能的演進非常迅速。例如，IPv4/IPv6 雙堆疊支援的發展就經歷了從實驗性功能到生產環境成熟應用的過程。我曾參與 kube-proxy 的開發和早期雙堆疊支援的工作，這段經歷讓我深刻體會到網路設計的重要性。一個穩固的網路架構如同 Kubernetes 叢集的根本，它直接影響著應用程式的效能、可靠性和安全性。

選擇合適的網路方案需要權衡多個因素，例如叢集規模、應用程式需求以及團隊的技術能力。對於小型叢集，單堆積疊 IPv4 可能就足夠了，但對於大型或需要全球佈署的應用程式，IPv6 或雙堆疊支援就變得不可或缺。服務發現和負載平衡的選擇也需要根據實際情況進行調整。服務網格可以提供更精細的流量控制和安全策略，但同時也增加了系統的複雜性。

除了網路根本，資源調配和安全防護也是構建高用性 Kubernetes 叢集的關鍵支柱。合理的資源分配如同為應用程式提供充足的資源，確保其穩定執行；而有效的安全策略則如同構建堅固的城牆，保護叢集免受攻擊。監控和日誌記錄如同哨兵，對於及時發現和解決問題至關重要。透過監控網路流量、資源使用情況和安全事件，我們可以快速識別潛在問題並採取相應措施。

構建高用性 Kubernetes 叢集需要通盤考慮網路、資源和安全等多個方面。選擇合適的技術方案並結合實踐經驗，才能構建一個穩定、高效與安全的 Kubernetes 平台。

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	http.HandleFunc("/", handler)
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	fmt.Printf("伺服器正在連線埠 %s 上監聽...\n", port)
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
}

func handler(w http.ResponseWriter, r *http.Request) {
	hostname, err := os.Hostname()
	if err != nil {
		fmt.Fprintf(w, "取得主機名稱時出錯: %v", err)
		return
	}

	fmt.Fprintf(w, "您好，世界！來自 %s\n", hostname)
}

這段 Go 程式碼建立了一個簡單的 Web 伺服器，回應 “您好，世界！” 並顯示目前 Pod 的主機名稱。這在 Kubernetes 環境中特別有用，因為每個 Pod 都有一個獨特的主機名稱，可以幫助識別正在處理請求的 Pod。main 函式設定 HTTP 路由處理程式並啟動伺服器，從環境變數 PORT 中讀取連線埠號，如果未設定，則預設使用 8080。handler 函式處理所有 HTTP 請求，取得 Pod 的主機名稱，並將其包含在回應訊息中。這個程式碼在 Kubernetes 中的應用很常見，每個 Pod 不同的主機名稱有助於追蹤請求路由。使用 fmt.Printf 輸出伺服器監聽的連線埠方便除錯，而回應中包含 Pod 主機名稱則方便識別。使用環境變數 PORT 設定連線埠號也更符合 Kubernetes 的最佳實踐。

package main

import (
	"fmt"
	"net/http"
)

func main() {
	http.HandleFunc("/healthz", healthz)
	http.HandleFunc("/", hello)
	fmt.Println("服務正在監聽中...")
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		panic(err)
	}
}

func healthz(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusOK)
}

func hello(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "Hello")
}

這段 Go 程式碼實作了一個簡單的 Web 伺服器，並包含 /healthz 健康檢查端點，這對於在 Kubernetes 中佈署應用程式至關重要。/healthz 端點回傳 200 OK 狀態碼，表示應用程式健康。/ 端點則回傳 “Hello” 訊息。在 Kubernetes 中，/healthz 端點可以設定為 liveness probe 或 readiness probe。Liveness probe 用於檢查應用程式是否正在執行，而 readiness probe 用於檢查應用程式是否已準備好接收流量。這個簡單的 Web 伺服器範例突顯了雲端原生應用程式中健康檢查的重要性。在雲端環境中，應用程式例項可能會動態地建立和銷毀，因此健康檢查對於確保系統的可靠性至關重要。您可以進一步擴充這個範例，新增指標收集、日誌記錄和組態管理等功能，以構建更健壯的雲端原生應用程式。

透過以上分析和程式碼範例，我們可以更清晰地理解如何構建高用性 Kubernetes 叢集。從網路基礎設施的選擇到資源調配和安全防護，每個環節都至關重要。 圖表的運用也讓技術概念更易於理解。希望這篇文章能幫助您在 Kubernetes 的旅程中更加順利。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。