在 GKE Standard 中部署 TPU 工作負載

本頁面提供基礎知識，說明如何在 Google Kubernetes Engine (GKE) 中使用 TPU 加速機器學習 (ML) 工作負載。TPU 專為矩陣乘法處理而設計，例如大規模深度學習模型訓練。TPU 經過最佳化，可處理機器學習的大量資料集和複雜模型，因此效能更勝一籌，在機器學習工作負載方面更具成本效益和能源效率。在本指南中，您將瞭解如何使用 Cloud TPU 加速器部署 ML 工作負載、設定 TPU 配額、設定執行 TPU 的節點集區升級，以及監控 TPU 工作負載指標。

本教學課程的適用對象為機器學習 (ML) 工程師、平台管理員和操作員，他們有興趣使用 Kubernetes 容器協調，透過 TPU 管理大規模模型訓練、調整和推論工作負載。如要進一步瞭解內容中提及的常見角色和範例工作，請參閱「常見的 GKE Enterprise 使用者角色和工作」。 Google Cloud

閱讀本頁面之前，請先熟悉下列概念：

事前準備

開始之前，請確認你已完成下列工作：

  • 啟用 Google Kubernetes Engine API。
    • 啟用 Google Kubernetes Engine API
  • 如要使用 Google Cloud CLI 執行這項工作，請安裝並初始化 gcloud CLI。如果您先前已安裝 gcloud CLI，請執行 gcloud components update，取得最新版本。

規劃 TPU 設定

請根據模型和所需的記憶體容量規劃 TPU 設定。使用本指南在 TPU 上部署工作負載前，請先完成「規劃 TPU 設定」中的規劃步驟。

確認您有 TPU 配額

下列各節說明如何確保在 GKE 中使用 TPU 時有足夠的配額。

隨選或 Spot VM 的配額

如果您要使用隨選或 Spot VM 建立 TPU 配量節點集區，您必須在要使用的地區擁有足夠的 TPU 配額。

建立會耗用 TPU 預留項目的 TPU 配量節點集區時，不需要任何 TPU 配額。1 您可以放心地略過預留 TPU 的這個部分。

在 GKE 中建立隨需或 Spot TPU 節點集區時，需要 Compute Engine API 配額。Compute Engine API 配額 (compute.googleapis.com) 與 Cloud TPU API 配額 (tpu.googleapis.com) 不同，後者是在使用 Cloud TPU API 建立 TPU 時所需。

如要查看 TPU 的 Compute Engine API 配額上限和目前用量，請按照下列步驟操作：

  1. 前往 Google Cloud 控制台的「配額」頁面：

    前往配額頁面

  2. 在「篩選器」方塊中，執行下列操作：

    1. 請參閱下表，根據 TPU 版本和機器類型選取並複製配額的屬性。舉例來說，如果您打算建立機器類型開頭為 ct5lp- 的隨選 TPU v5e 節點，請輸入 Name: TPU v5 Lite PodSlice chips。

      TPU 版本、機器類型開頭為 隨選執行個體配額的屬性和名稱 Spot 2 執行個體的配額屬性和名稱
      TPU v3，
      ct3- 
      Dimensions (e.g. location):
      tpu_family:CT3
      		 不適用
      TPU v3、
      ct3p- 
      Dimensions (e.g. location):
      tpu_family:CT3P
      		 不適用
      TPU v4、
      ct4p- 
      Name:
      TPU v4 PodSlice chips
      		 
      Name:
      Preemptible TPU v4 PodSlice chips
      TPU v5e、
      ct5lp- 
      Name:
      TPU v5 Lite PodSlice chips
      		 
      Name:
      Preemptible TPU v5 Lite Podslice
      chips
      TPU v5p、
      ct5p- 
      Name:
      TPU v5p chips
      		 
      Name:
      Preemptible TPU v5p chips
      TPU Trillium、
      ct6e- 
      Dimensions (e.g. location):
      tpu_family:CT6E
      		 
      Name:
      Preemptible TPU slices v6e

    2. 選取「Dimensions (e.g. locations)」(維度，例如位置) 屬性，然後輸入 region:，接著輸入您打算在 GKE 中建立 TPU 的區域名稱。舉例來說，如果您打算在 us-west4-a 區域建立 TPU 節點，請輸入 region:us-west4。TPU 配額屬於區域性配額，因此同一區域內的所有可用區都會消耗相同的 TPU 配額。

如果沒有任何配額符合您輸入的篩選條件，表示專案在您需要的區域中未獲得任何指定配額，因此您必須申請調整 TPU 配額。

建立 TPU 預訂時，對應配額的上限和目前用量值都會增加，增幅為 TPU 預訂中的晶片數量。舉例來說，如果為 16 個 TPU v5e 晶片建立預訂，且機器類型開頭為 ct5lp-，則相關區域中 TPU v5 Lite PodSlice chips 配額的「限制」和「目前用量」都會增加 16。

  1. 建立 TPU 節點集區時，請使用 --reservation 和 --reservation-affinity=specific 標記建立預留執行個體。購買承諾時，即可使用 TPU 預留項目。↩

  2. 建立 TPU 節點集區時，請使用 --spot 標記建立 Spot 執行個體。↩

其他 GKE 資源的配額

您可能需要在 GKE 建立資源的區域中，增加下列 GKE 相關配額。

  • SSD 永久磁碟 (GB) 配額：每個 Kubernetes 節點的開機磁碟預設需要 100 GB。因此，這項配額至少應設為您預計建立的 GKE 節點數量上限與 100 GB 的乘積 (節點 * 100 GB)。
  • 使用中 IP 位址配額：每個 Kubernetes 節點會占用一個 IP 位址。 因此，這項配額至少應設為您預期建立的 GKE 節點數量上限。
  • 確認 max-pods-per-node 與子網路範圍一致：每個 Kubernetes 節點都會使用次要 IP 範圍做為 Pod。舉例來說，32 個 Pod max-pods-per-node 需要 64 個 IP 位址，因此每個節點需要 /26 子網路。 請注意，這個範圍不得與任何其他叢集共用。為避免 IP 位址範圍用盡，請使用 --max-pods-per-node 旗標，限制可在節點上排程的 Pod 數量。max-pods-per-node 的配額應至少設為您預計建立的 GKE 節點數量上限。

如要申請提高配額，請參閱「申請調整配額」一文。

確認預訂是否適用

建立保留的 TPU 配量節點集區 (會耗用保留項目) 時，不需要任何 TPU 配額。不過，建立節點集區時，保留項目必須有足夠的可用或未使用的 TPU 晶片。

如要查看專案中的現有預留項目，以及 TPU 預留項目中可用的 TPU 晶片數量，請查看預留項目清單。

在 GKE 中佈建 TPU 的選項

在 GKE 中，您可以在工作負載資訊清單中使用 Kubernetes nodeSelector，或建立含有 TPU 的標準模式節點集區，直接在個別工作負載中使用 TPU。

或者，您也可以使用自訂運算類別要求 TPU。平台管理員可以透過自訂運算類別，為 GKE 定義節點設定的階層，以便在決定節點資源調度時優先採用，確保工作負載在您選取的硬體上執行。

如需操作說明，請參閱「使用自訂運算類別佈建 TPU」一節。

建立叢集

在有可用 TPU 的區域中，以 Standard 模式建立 GKE 叢集。

最佳做法：

使用區域叢集，確保 Kubernetes 控制層具備高可用性。

gcloud container clusters create CLUSTER_NAME \
  --location LOCATION \
  --cluster-version VERSION

更改下列內容：

  • CLUSTER_NAME：新叢集的名稱。
  • LOCATION：提供 TPU 容量的區域。
  • VERSION：GKE 版本，必須支援您想使用的機器類型。請注意，預設 GKE 版本可能無法用於目標 TPU。如要瞭解各 TPU 機型適用的最低 GKE 版本，請參閱「GKE 中的 TPU 可用性」。

建立節點集區

您可以建立單一或多主機 TPU 配量節點集區。

建立單一主機 TPU 節點集區

您可以使用 Google Cloud CLI、Terraform 或 Google Cloud 控制台，建立單一主機 TPU 節點集區。

gcloud

gcloud container node-pools create NODE_POOL_NAME \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --node-locations=NODE_ZONES \
    --machine-type=MACHINE_TYPE \
    [--sandbox=type=gvisor]

更改下列內容：

  • NODE_POOL_NAME：新節點集區的名稱。
  • LOCATION：可用區名稱，取決於您要使用的 TPU 版本。如要找出可用位置，請參閱「GKE 中的 TPU 可用性」。
  • CLUSTER_NAME：叢集名稱。
  • NODE_ZONES：以半形逗號分隔的清單，列出 GKE 建立節點集區的一或多個可用區。
  • MACHINE_TYPE：節點使用的機器類型。如要進一步瞭解與 TPU 相容的機器類型，請參閱「選擇 TPU 版本」一文中的表格。

您也可以視需要使用下列標記：

  • --num-nodes=NUM_NODES：每個可用區中節點集區的初始節點數量。如果省略這個標記，GKE 會指派預設值 3，

    最佳做法：

    如果您為節點集區使用 enable-autoscaling 標記，請將 num-nodes 設為 0，這樣一來，自動調度器就會在工作負載需要時，立即佈建額外節點。

  • --reservation=RESERVATION_NAME：GKE 在建立節點集區時使用的預留空間名稱。如果省略這個標記，GKE 會使用可用的 TPU。如要進一步瞭解 TPU 預留資源，請參閱 TPU 預留資源。

  • --node-labels cloud.google.com/gke-workload-type=HIGH_AVAILABILITY：告知 GKE 單一主機 TPU 配量節點集區屬於集合。如符合下列條件，請使用這個標記：

    • 節點集區會在新的節點集區中執行推論工作負載。
    • 節點集區使用 TPU Trillium。
    • 節點集區未使用 Spot VM。

    如要進一步瞭解集合排程管理，請參閱「在單一主機 TPU 切片中管理集合排程」。

  • --enable-autoscaling：建立啟用自動調度資源功能的節點集區。 需要下列額外旗標：

    • --total-min-nodes=TOTAL_MIN_NODES：節點集區中所有節點的數量下限。
    • --total-max-nodes=TOTAL_MAX_NODES：節點集區中所有節點的數量上限。
    • --location-policy=ANY：優先使用未使用的預訂項目，並降低 Spot VM 的先占風險。

  • --spot：將節點集區設為使用Spot VM，適用於節點集區中的節點。節點集區建立後即無法變更這項設定。

  • --flex-start：將節點集區設為使用彈性啟動佈建模式。

  • --sandbox=type=gvisor：佈建已啟用 GKE Sandbox 的節點。需要 TPU v4 以上版本。詳情請參閱「GKE Sandbox」。

如要查看可指定的所有旗標完整清單，請參閱 gcloud container clusters create 參考資料。

Terraform

  1. 請確認您使用的是 google 4.84.0 以上版本。
  2. 在 Terraform 設定中新增下列區塊：
resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" {
  provider           = google
  project            = PROJECT_ID
  cluster            = CLUSTER_NAME
  name               = POOL_NAME
  location           = CLUSTER_LOCATION
  node_locations     = [NODE_ZONES]

  node_config {
    machine_type = MACHINE_TYPE
    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key = "compute.googleapis.com/reservation-name"
      values = [RESERVATION_LABEL_VALUES]
    }
    spot = true
    flex_start = false
  }
}

更改下列內容：

  • NODE_POOL_RESOURCE_NAME：Terraform 範本中的節點集區資源名稱。
  • PROJECT_ID：您的專案 ID。
  • CLUSTER_NAME：現有叢集的名稱。
  • POOL_NAME：要建立的節點集區名稱。
  • CLUSTER_LOCATION：叢集的運算可用區。指定提供 TPU 版本的區域。詳情請參閱「選取 TPU 版本和拓撲」。
  • NODE_ZONES：以半形逗號分隔的清單，列出 GKE 建立節點集區的一或多個可用區。
  • MACHINE_TYPE：要使用的 TPU 機器類型。如要查看與 TPU 相容的機器類型，請參閱「選擇 TPU 版本」一文中的表格。

您也可以視需要使用下列變數：

  • autoscaling：建立啟用自動調度資源功能的節點集區。如果是單一主機 TPU 配量，GKE 會在 TOTAL_MIN_NODES 和 TOTAL_MAX_NODES 值之間進行調整。
    • TOTAL_MIN_NODES：節點集區中所有節點的數量下限。除非也指定自動調度，否則此欄位為選填。
    • TOTAL_MAX_NODES：節點集區中所有節點的數量上限。除非也指定自動調度，否則此欄位為選填。
  • RESERVATION_NAME：如果您使用 TPU 預留，這是建立節點集區時要使用的預留資源標籤清單。如要進一步瞭解如何填入 RESERVATION_LABEL_VALUES 欄位中的 reservation_affinity，請參閱 Terraform 供應商。
  • spot：將節點集區設為使用 Spot VM 做為 TPU 節點。節點集區建立後即無法變更這項設定。詳情請參閱「Spot VM」。
  • flex_start：將節點集區設為使用彈性啟動佈建模式。如果已啟用 spot，則無法設為 true。

控制台

如要建立具有 TPU 的節點集區：

  1. 前往 Google Cloud 控制台的「Google Kubernetes Engine」頁面。

    前往「Google Kubernetes Engine」

  2. 在叢集清單中，按一下您要修改的叢集名稱。

  3. 按一下 「Add node pool」(新增節點集區)。

  4. 在「節點集區詳細資料」部分，勾選「指定節點位置」方塊。

  5. 根據要使用的 TPU 版本選取區域。如要找出可用區域，請參閱「GKE 中的 TPU 可用性」。

  6. 按一下導覽窗格中的「Nodes」(節點)。

  7. 在「機器設定」專區中，選取「TPU」。

  8. 在「系列」下拉式選單中，選取下列其中一個選項：

    • CT3：TPU v3，單一主機裝置
    • CT3P：TPU v3，多主機 Pod 配量
    • CT4P：TPU v4
    • CT5LP：TPU v5e
    • CT5P：TPU v5p
    • CT6E：TPU Trillium (v6e)

  9. 在「Machine type」(機器類型) 下拉式選單中，選取要用於節點的機器名稱。請參閱「選擇 TPU 版本」表格，瞭解如何定義機器類型和 TPU 拓撲，以建立單一主機 TPU 配量節點集區。

  10. 在「TPU Topology」(TPU 拓撲) 下拉式選單中，選取 TPU 配量的實體拓撲。

  11. 在「需要變更」對話方塊中，按一下「進行變更」。

  12. 確認「開機磁碟類型」為「標準永久磁碟」或「SSD 永久磁碟」。

  13. 或者，您也可以勾選「啟用 Spot VM 上的節點」核取方塊，為節點集區中的節點使用 Spot VM。

  14. 點選「建立」。

建立多主機 TPU 配量節點集區

您可以使用 Google Cloud CLI、Terraform 或 Google Cloud 控制台，建立多主機 TPU 節點集區。

gcloud

gcloud container node-pools create POOL_NAME \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --node-locations=NODE_ZONES \
    --machine-type=MACHINE_TYPE \
    --tpu-topology=TPU_TOPOLOGY \
    [--num-nodes=NUM_NODES] \
    [--spot \]
    [--flex-start \]
    [--enable-autoscaling \
      --max-nodes MAX_NODES]
    [--reservation-affinity=specific \
    --reservation=RESERVATION_NAME] \
    [--node-labels cloud.google.com/gke-nodepool-group-name=COLLECTION_NAME,cloud.google.com/gke-workload-type=HIGH_AVAILABILITY]
    [--placement-type=COMPACT]

更改下列內容：

  • POOL_NAME：新節點集區的名稱。
  • LOCATION：可用區名稱，取決於您要使用的 TPU 版本。如要找出可用位置，請參閱「GKE 中的 TPU 可用性」。
  • CLUSTER_NAME：叢集名稱。
  • NODE_ZONES：以半形逗號分隔的清單，列出 GKE 建立節點集區的一或多個可用區。
  • MACHINE_TYPE：節點使用的機器類型。如要進一步瞭解可用的機器類型，請參閱「選擇 TPU 版本」。

  • TPU_TOPOLOGY：TPU 配量的實體拓撲。拓撲格式取決於 TPU 版本。如要進一步瞭解 TPU 拓撲，請參閱「選擇拓撲」一文中的表格。

    詳情請參閱「拓撲」。

您也可以視需要使用下列標記：

  • NUM_NODES：節點集區中的節點數量。這個值必須為零，或是 TPU_TOPOLOGY ({A}x{B}x{C}) 中定義的值的乘積，除以每個 VM 中的晶片數。如果是多主機 TPU v4 和 TPU v5e，每個 VM 的晶片數量為四個。因此，如果您的 TPU_TOPOLOGY 是 2x4x4 (每個 VM 有四個晶片的 TPU v4)，則 NUM_NODES 為 32/4，等於 8。如果省略這個旗標，系統會根據拓撲和機器類型計算節點數量，並預設為該數量。
  • RESERVATION_NAME：GKE 在建立節點集區時使用的預留空間名稱。如果省略這個旗標，GKE 會使用可用的 TPU 配量節點集區。如要進一步瞭解 TPU 預訂，請參閱 TPU 預訂。
  • --spot：將節點集區設為使用 Spot VM 做為 TPU 配量節點。節點集區建立後即無法變更這項設定。詳情請參閱「Spot VM」。
  • --flex-start：將節點集區設為使用彈性啟動佈建模式。

  • --enable-autoscaling：建立啟用自動調度資源功能的節點集區。當 GKE 擴大多主機 TPU 配量節點集區時，會不可分割地將節點集區從零擴大到最大大小。

    • MAX_NODES：節點集區的大小上限。如果提供 --enable-autoscaling，則必須提供 --max-nodes 旗標，且該旗標必須等於 TPU_TOPOLOGY ({A}x{B}x{C}) 中定義的值除以每個 VM 中的晶片數。

  • --node-label=cloud.google.com/gke-nodepool-group-name=COLLECTION_NAME, cloud.google.com/gke-workload-type=HIGH_AVAILABILITY：告知 GKE 多主機 TPU 配量節點集區是集合。如符合下列條件，請使用這個標記：

    • 節點集區會在新的節點集區中執行推論工作負載。
    • 節點集區使用 TPU Trillium。
    • Spot VM 不支援收集排程。

    如要進一步瞭解如何管理集合排程，請參閱「在多主機 TPU 切片中管理集合排程」。

  • --placement-type=COMPACT：建立啟用密集配置的節點集區。 這個選項必須與 --tpu-topology 旗標搭配使用。 詳情請參閱「建立密集配置政策」和「TPU 拓撲」。

Terraform

  1. 請確認您使用的是 google 4.84.0 以上版本。

  2. 在 Terraform 設定中新增下列區塊：

    resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" {
  provider           = google
  project            = PROJECT_ID
  cluster            = CLUSTER_NAME
  name               = POOL_NAME
  location           = CLUSTER_LOCATION
  node_locations     = [NODE_ZONES]
  initial_node_count = NUM_NODES

  autoscaling {
    max_node_count = MAX_NODES
    location_policy      = "ANY"
  }
  node_config {
    machine_type = MACHINE_TYPE
    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key = "compute.googleapis.com/reservation-name"
      values = [RESERVATION_LABEL_VALUES]
    }
    spot = true
    flex_start = false
  }

  placement_policy {
    type = "COMPACT"
    tpu_topology = TPU_TOPOLOGY
  }
}

    更改下列內容：

    • NODE_POOL_RESOURCE_NAME：Terraform 範本中的節點集區資源名稱。
    • PROJECT_ID：您的專案 ID。
    • CLUSTER_NAME：要新增節點集區的現有叢集名稱。
    • POOL_NAME：要建立的節點集區名稱。
    • CLUSTER_LOCATION：叢集的運算位置。建議您使用區域叢集，提高 Kubernetes 控制層的可靠性。您也可以使用區域叢集。 詳情請參閱「選取 TPU 版本和拓撲」。
    • NODE_ZONES：以半形逗號分隔的清單，列出 GKE 建立節點集區的一或多個可用區。
    • NUM_NODES：節點集區中的節點數量。這個值必須是零，或是 TPU 晶片數量除以四的結果，因為在多主機 TPU 配量中，每個 TPU 配量節點都有 4 個晶片。舉例來說，如果 TPU_TOPOLOGY 是 4x8，則代表有 32 個晶片，因此 NUM_NODES 必須是 8。如要進一步瞭解 TPU 拓撲，請參閱「選擇 TPU 版本」一文中的表格。
    • TPU_TOPOLOGY：這表示 TPU 配量的所需實體拓撲。拓撲格式取決於所用 TPU 版本。如要進一步瞭解 TPU 拓撲，請參閱「選擇拓撲」一文中的表格。

    您也可以視需要使用下列變數：

    • RESERVATION_NAME：如果您使用 TPU 預留，這是建立節點集區時要使用的預留資源標籤清單。如要進一步瞭解如何填入 reservation_affinity 欄位中的 RESERVATION_LABEL_VALUES，請參閱 Terraform 供應商。
    • autoscaling：建立啟用自動調度資源功能的節點集區。當 GKE 擴大多主機 TPU 配量節點集區時，會不可分割地將節點集區從零擴大到最大大小。
      • MAX_NODES：節點集區的大小上限。這個值必須等於 TPU_TOPOLOGY ({A}x{B}x{C}) 中定義的值的乘積，除以每個 VM 中的晶片數。
    • spot：允許節點集區將 Spot VM 用於 TPU 配量節點。節點集區建立後即無法變更這項設定。詳情請參閱「Spot VM」。
    • flex_start：將節點集區設為使用彈性啟動佈建模式。如果已啟用 spot，則無法設為 true。

控制台

如要建立具有 TPU 的節點集區：

  1. 前往 Google Cloud 控制台的「Google Kubernetes Engine」頁面。

    前往「Google Kubernetes Engine」

  2. 在叢集清單中，按一下您要修改的叢集名稱。

  3. 按一下 「Add node pool」(新增節點集區)。

  4. 在「節點集區詳細資料」部分，勾選「指定節點位置」方塊。

  5. 根據要使用的 TPU 版本選取區域名稱。如要找出可用位置，請參閱「GKE 中的 TPU 可用性」。

  6. 按一下導覽窗格中的「Nodes」(節點)。

  7. 在「機器設定」專區中，選取「TPU」。

  8. 在「系列」下拉式選單中，選取下列其中一個選項：

    • CT3P：適用於 TPU v3。
    • CT4P：適用於 TPU v4。
    • CT5LP：適用於 TPU v5e。

  9. 在「Machine type」(機器類型) 下拉式選單中，選取要用於節點的機器名稱。請參閱「選擇 TPU 版本」表格，瞭解如何定義機器類型和 TPU 拓撲，以建立多主機 TPU 配量節點集區。

  10. 在「TPU Topology」(TPU 拓撲) 下拉式選單中，選取 TPU 配量的實體拓撲。

  11. 在「需要變更」對話方塊中，按一下「進行變更」。

  12. 確認「開機磁碟類型」為「標準永久磁碟」或「SSD 永久磁碟」。

  13. 如要為節點集區中的節點使用 Spot VM，請勾選「啟用 Spot VM 上的節點」核取方塊。

  14. 點選「建立」。

GKE 如何處理容量問題

如果 GKE 無法建立 TPU 配量節點集區，可能是因為 TPU 容量不足，GKE 會傳回錯誤訊息，指出因容量不足而無法建立 TPU 配量節點。

如果您要建立單一主機 TPU 配量節點集區，錯誤訊息會類似於以下內容：

2 nodes cannot be created due to lack of capacity. The missing nodes will be
created asynchronously once capacity is available. You can either wait for the
nodes to be up, or delete the node pool and try re-creating it again later.

如果您要建立多主機 TPU 配量節點集區，錯誤訊息會類似於以下內容：

The nodes (managed by ...) cannot be created now due to lack of capacity. They
will be created asynchronously once capacity is available. You can either wait
for the nodes to be up, or delete the node pool and try re-creating it again
later.

TPU 佈建要求可能會在佇列中停留很長一段時間，且在佇列中會維持「佈建」狀態。

資源充足後，GKE 會建立其餘未建立的節點。

如果需要容量，請考慮使用 Spot VM，但請注意，Spot VM 使用的配額與隨選執行個體不同。

如要刪除排入佇列的 TPU 要求，請刪除 TPU 節點集區。

在 TPU 配量節點上執行工作負載

本節說明如何準備工作負載，以及如何執行工作負載的範例。

準備工作負載

TPU 工作負載必須符合下列準備條件。

  1. JAX、PyTorch 和 TensorFlow 等架構會使用 libtpu 共用程式庫存取 TPU VM。libtpu 包含 XLA 編譯器、TPU 執行階段軟體和 TPU 驅動程式。每個版本的 PyTorch 和 JAX 都需要特定版本的 libtpu.so。如要在 GKE 中使用 TPU，請務必使用下列版本：
    TPU 類型 「libtpu.so」版本
    TPU Trillium (v6e)
    tpu-v6e-slice
    TPU v5e
    tpu-v5-lite-podslice
    TPU v5p
    tpu-v5p-slice
    • 建議使用 0.4.19 以上版本的 jax[tpu]。
    • 建議使用的 torchxla[tpuvm] 版本：建議使用 2023 年 10 月 23 日建構的每夜版本。
    TPU v4
    tpu-v4-podslice
    TPU v3
    tpu-v3-slice
    tpu-v3-device
  2. 為要求 TPU 資源的容器設定下列環境變數：
    • TPU_WORKER_ID：每個 Pod 的專屬整數。這個 ID 代表 TPU 切片中的專屬工作者 ID。這個欄位支援的值範圍為零到 Pod 數量減一。
    • TPU_WORKER_HOSTNAMES：以半形逗號分隔的 TPU VM 主機名稱或 IP 位址清單，這些主機或位址需要在切片內彼此通訊。每個 TPU VM 應都有主機名稱或 IP 位址。IP 位址或主機名稱清單會依 TPU_WORKER_ID 排序，並以零為索引。

      • 使用 completionMode: Indexed、subdomain、parallelism > 1 建立 Job，並要求 google.com/tpu 屬性時，GKE 會使用變動 Webhook 自動插入這些環境變數。GKE 會新增無標題的服務，以便為支援服務的 Pod 新增 DNS 記錄。

      使用 Kuberay 部署 TPU 多主機資源時，GKE 會提供可部署的網頁掛鉤，做為在 GKE 上執行 Ray 的實驗性 Terraform 範本。如需使用 TPU 在 GKE 中執行 Ray 的操作說明，請參閱實驗性的 TPU 使用者指南。變動 Webhook 會將這些環境變數插入要求 google.com/tpu 屬性和多主機 cloud.google.com/gke-tpu-topology 節點選取器的 Ray 叢集。

    • 在工作負載資訊清單中新增 Kubernetes 節點選取器，確保 GKE 會在您定義的 TPU 機器類型和 TPU 拓撲上排定 TPU 工作負載：

        nodeSelector:
    cloud.google.com/gke-tpu-accelerator: TPU_ACCELERATOR
    cloud.google.com/gke-tpu-topology: TPU_TOPOLOGY

      更改下列內容：

完成工作負載準備後，即可執行使用 TPU 的工作。

以下各節提供範例，說明如何執行使用 TPU 執行簡單運算的工作。

範例 1：執行工作負載，顯示 TPU 節點集區中可用的 TPU 晶片數量

下列工作負載會傳回多主機 TPU 節點中所有節點的 TPU 晶片數量。如要建立多主機切片，工作負載必須具備下列參數：

  • TPU 版本：TPU v4
  • 拓撲：2x2x4

這個版本和拓撲選取項目會產生多主機配量。

  1. 將下列資訊清單儲存為 available-chips-multihost.yaml： 
    apiVersion: v1
kind: Service
metadata:
  name: headless-svc
spec:
  clusterIP: None
  selector:
    job-name: tpu-available-chips
---
apiVersion: batch/v1
kind: Job
metadata:
  name: tpu-available-chips
spec:
  backoffLimit: 0
  completions: 4
  parallelism: 4
  completionMode: Indexed
  template:
    spec:
      subdomain: headless-svc
      restartPolicy: Never
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice
        cloud.google.com/gke-tpu-topology: 2x2x4
      containers:
      - name: tpu-job
        image: python:3.10
        ports:
        - containerPort: 8471 # Default port using which TPU VMs communicate
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        securityContext:
          privileged: true
        command:
        - bash
        - -c
        - |
          pip install 'jax[tpu]' -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
          python -c 'import jax; print("TPU cores:", jax.device_count())'
        resources:
          requests:
            cpu: 10
            memory: 407Gi
            google.com/tpu: 4
          limits:
            cpu: 10
            memory: 407Gi
            google.com/tpu: 4
  2. 部署資訊清單： 
    kubectl create -f available-chips-multihost.yaml

    GKE 會執行含有四個 VM 的 TPU v4 配量 (多主機 TPU 配量)。配量有 16 個互連的 TPU 晶片。

  3. 確認 Job 已建立四個 Pod： 
    kubectl get pods

    輸出結果會與下列內容相似：

    NAME                       READY   STATUS      RESTARTS   AGE
tpu-job-podslice-0-5cd8r   0/1     Completed   0          97s
tpu-job-podslice-1-lqqxt   0/1     Completed   0          97s
tpu-job-podslice-2-f6kwh   0/1     Completed   0          97s
tpu-job-podslice-3-m8b5c   0/1     Completed   0          97s
  4. 取得其中一個 Pod 的記錄： 
    kubectl logs POD_NAME

    將 POD_NAME 替換為其中一個已建立的 Pod 名稱。例如：tpu-job-podslice-0-5cd8r。

    輸出結果會與下列內容相似：

    TPU cores: 16
  5. (選用) 移除工作負載： 
    kubectl delete -f available-chips-multihost.yaml

範例 2：執行工作負載，顯示 TPU 配量中可用的 TPU 晶片數量

下列工作負載是靜態 Pod，會顯示附加至特定節點的 TPU 晶片數量。如要建立單一主機節點，工作負載必須具備下列參數：

  • TPU 版本：TPU v5e
  • 拓撲：2x4

這個版本和拓撲選取項目會產生單一主機配量。

  1. 將下列資訊清單儲存為 available-chips-singlehost.yaml： 
    apiVersion: v1
kind: Pod
metadata:
  name: tpu-job-jax-v5
spec:
  restartPolicy: Never
  nodeSelector:
    cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
    cloud.google.com/gke-tpu-topology: 2x4
  containers:
  - name: tpu-job
    image: python:3.10
    ports:
    - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
    securityContext:
      privileged: true
    command:
    - bash
    - -c
    - |
      pip install 'jax[tpu]' -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
      python -c 'import jax; print("Total TPU chips:", jax.device_count())'
    resources:
      requests:
        google.com/tpu: 8
      limits:
        google.com/tpu: 8
  2. 部署資訊清單： 
    kubectl create -f available-chips-singlehost.yaml

    GKE 會佈建節點，其中包含八個使用 TPU v5e 的單一主機 TPU 配量。每個 TPU 節點有八個 TPU 晶片 (單一主機 TPU 配量)。

  3. 取得 Pod 的記錄： 
    kubectl logs tpu-job-jax-v5

    輸出結果會與下列內容相似：

    Total TPU chips: 8
  4. (選用) 移除工作負載： 
      kubectl delete -f available-chips-singlehost.yaml

使用加速器 (GPU 和 TPU) 升級節點集區

GKE 會自動升級標準叢集，包括節點集區。如要讓節點更快升級至較新版本，也可以手動升級節點集區。如要控管叢集的升級方式，請使用發布版本、維護期間和排除時段，以及推出順序。

您也可以為節點集區設定節點升級策略，例如節點數擴充升級、藍綠升級或短期升級。設定這些策略後，即可確保節點集區升級時，能兼顧速度和環境中斷情形，達到最佳平衡。如果是多主機 TPU 配量節點集區，GKE 會在單一步驟中，以不可分割的方式重新建立整個節點集區，而不是使用已設定的節點升級策略。詳情請參閱「GKE 中的 TPU 相關術語」一文中的「原子性」定義。

使用節點升級策略時，GKE 必須暫時佈建額外資源 (視設定而定)。如果 Google Cloud節點集區的資源容量有限 (例如，嘗試使用 GPU 或 TPU 建立更多節點時，看到資源可用性錯誤)，請參閱「在資源受限的環境中升級」。

清除所用資源

為避免系統向您的 Google Cloud 帳戶收取本指南所用資源的費用，請考慮刪除不再排定工作負載的 TPU 節點集區。如果執行的工作負載必須正常終止，請先使用 kubectl drain 清理工作負載，再刪除節點。

  1. 刪除 TPU 節點集區：

    gcloud container node-pools delete POOL_NAME \
    --location=LOCATION \
    --cluster=CLUSTER_NAME

    更改下列內容：

    • POOL_NAME：節點集區的名稱。
    • CLUSTER_NAME：叢集名稱。
    • LOCATION：叢集的運算位置。

進行其他設定

以下各節說明可套用至 TPU 工作負載的其他設定。

管理收藏內容排程

在 TPU Trillium 中，您可以使用集合排程，將 TPU 節點切片分組。將這些 TPU 節點分組後，就能更輕鬆地調整副本數量，以滿足工作負載需求。 Google Cloud 會控管軟體更新，確保集合內有足夠的切片，隨時可處理流量。

TPU Trillium 支援單一主機和多主機節點集區的集合排程，可執行推論工作負載。以下說明收集排程行為如何取決於所用 TPU 配量類型：

  • 多主機 TPU 配量：GKE 會將多主機 TPU 配量分組，形成集合。每個 GKE 節點集區都是這個集合中的副本。如要定義集合，請建立多主機 TPU 配量，並為集合指派專屬名稱。如要將更多 TPU 節點加入集合，請建立另一個多主機 TPU 節點集區，並使用相同的集合名稱和工作負載類型。
  • 單一主機 TPU 配量：GKE 會將整個單一主機 TPU 配量節點集區視為一個集合。如要將更多 TPU 配量新增至集合，可以調整單一主機 TPU 配量節點集區的大小。

如要管理集合，請根據使用的節點集區類型執行下列任一動作。

在多主機 TPU 配量節點集區中管理集合排程

請使用下列工作管理多主機 TPU 配量節點集區。

  • 如要檢查多主機 TPU 節點集區是否屬於集合，請執行下列指令：

    gcloud container node-pools describe NODE_POOL_NAME \
    --location LOCATION \
    --cluster CLUSTER_NAME \
    --format="json" | jq -r \
    '"nodepool-group-name: \(.config.labels["cloud.google.com/gke-nodepool-group-name"] // "")\ngke-workload-type: \(.config.labels["cloud.google.com/gke-workload-type"] // "")"'

    輸出結果會與下列內容相似：

    nodepool-group-name: <code><var>NODE_POOL_COLLECTION_NAME</var></code>
gke-workload-type: HIGH_AVAILABILITY

    如果多主機 TPU 配量集區是集合的一部分，輸出內容會包含下列標籤：

    • cloud.google.com/gke-workload-type: HIGH_AVAILABILITY
    • cloud.google.com/gke-nodepool-group-name: <code><var>COLLECTION_NAME</var></code>

  • 如要取得叢集中的集合清單，請執行下列指令：

    #!/bin/bash

# Replace with your cluster name, project, and location
CLUSTER_NAME=CLUSTER_NAME
PROJECT=PROJECT_ID
LOCATION=LOCATION

declare -A collection_names

node_pools=$(gcloud container node-pools list --cluster "$CLUSTER_NAME" --project "$PROJECT" --location "$LOCATION" --format="value(name)")

# Iterate over each node pool
for pool in $node_pools; do
    # Describe the node pool and extract labels using jq
    collection_name=$(gcloud container node-pools describe "$pool" \
        --cluster "$CLUSTER_NAME" \
        --project "$PROJECT" \
        --location "$LOCATION" \
        --format="json" | jq -r '.config.labels["cloud.google.com/gke-nodepool-group-name"]')

    # Add the collection name to the associative array if it's not empty
    if [[ -n "$collection_name" ]]; then
        collection_names["$collection_name"]=1
    fi
done

# Print the unique node pool collection names
echo "Unique cloud.google.com/gke-nodepool-group-name values:"
for name in "${!collection_names[@]}"; do
    echo "$name"
done

    輸出結果會與下列內容相似：

    Unique cloud.google.com/gke-nodepool-group-name values: {COLLECTION_NAME_1}, {COLLECTION_NAME_2}, {COLLECTION_NAME_3}

  • 如要取得集合所屬的節點集區清單，請執行下列指令：

    #!/bin/bash

TARGET_COLLECTION_NAME=COLLECTION_NAME
CLUSTER_NAME=CLUSTER_NAME
PROJECT=PROJECT_ID
LOCATION=LOCATION

matching_node_pools=()

# Get the list of all node pools in the cluster
node_pools=$(gcloud container node-pools list --cluster "$CLUSTER_NAME" --project "$PROJECT" --location "$LOCATION" --format="value(name)")

# Iterate over each node pool
for pool in $node_pools; do
    # Get the value of the cloud.google.com/gke-nodepool-group-name label
    collection_name=$(gcloud container node-pools describe "$pool" \
        --cluster "$CLUSTER_NAME" \
        --project "$PROJECT" \
        --location "$LOCATION" \
        --format="json" | jq -r '.config.labels["cloud.google.com/gke-nodepool-group-name"]')

    # Check if the group name matches the target value
    if [[ "$collection_name" == "$TARGET_COLLECTION_NAME" ]]; then
        matching_node_pools+=("$pool")
    fi
done

# Print the list of matching node pools
echo "Node pools with collection name '$TARGET_COLLECTION_NAME':"
for pool in "${matching_node_pools[@]}"; do
    echo "$pool"
done

    輸出結果會與下列內容相似：

    Node pools with collection name 'COLLECTION_NAME':
{NODE_POOL_NAME_1}
{NODE_POOL_NAME_2}
{NODE_POOL_NAME_3}

  • 如要擴大集合，請建立另一個多主機 TPU 配量節點集區，並新增 cloud.google.com/gke-workload-type 和 cloud.google.com/gke-nodepool-group-name。在 cloud.google.com/gke-nodepool-group-name 中使用相同的集合名稱，並執行相同的工作負載類型。如果叢集已啟用節點自動佈建功能，GKE 會根據工作負載需求自動建立集區。

  • 如要縮減集合，請刪除節點集區。

  • 如要刪除集合，請移除所有附加的節點集區。您可以刪除節點集區或刪除叢集。刪除叢集會一併移除其中的所有集合。

在單一主機 TPU 節點集區中管理收集作業排程

使用下列工作管理單一主機 TPU 節點集區。

  • 如要檢查單一主機 TPU 節點集區是否已啟用集合排程，請執行下列指令：

    gcloud container node-pools describe NODE_POOL_NAME \
    --cluster CLUSTER_NAME \
    --project PROJECT_NAME \
    --location LOCATION \
    --format="json" | jq -r '.config.labels["cloud.google.com/gke-workload-type"]'

    輸出結果會與下列內容相似：

    gke-workload-type: HIGH_AVAILABILITY

    如果單一主機 TPU 配量集區屬於集合，輸出內容會包含 cloud.google.com/gke-workload-type: HIGH_AVAILABILITY 標籤。

  • 如要擴充集合，請手動或自動調整節點集區大小，並使用節點自動佈建功能。

  • 如要縮減集合，請刪除節點集區。

  • 如要刪除集合，請移除所有附加的節點集區。您可以刪除節點集區或刪除叢集。刪除叢集會一併移除其中的所有集合。

使用多配量

您可以在 Multislice 中匯總較小的配量，以處理較大的訓練工作負載。詳情請參閱「GKE 中的多切片 TPU」。

遷移 TPU 預訂

如果您有現有的 TPU 預訂，請務必先將 TPU 預訂遷移至新的 Compute Engine 預訂系統。您也可以建立以 Compute Engine 為基礎的預訂系統，不需要遷移。如要瞭解如何遷移 TPU 預留項目，請參閱 TPU 預留項目。

啟用記錄功能

GKE 節點 (包括 TPU VM) 上執行的容器所產生的記錄檔，會由 GKE 記錄代理程式收集，並傳送至 Logging，然後顯示在 Logging 中。

使用 GKE 節點自動佈建功能

您可以設定 GKE 自動建立及刪除節點集區，滿足 TPU 工作負載的資源需求。詳情請參閱設定 Cloud TPU。

使用自訂運算類別佈建 TPU

您也可以使用自訂運算類別，在建立新節點的擴充作業期間，設定 GKE 要求 TPU。

您可以在自訂運算類別規格中指定 TPU 設定選項。當 GKE 工作負載使用該自訂運算類別時，GKE 會嘗試在擴充時，佈建使用您指定設定的 TPU。

如要使用符合 TPU 規則的自訂運算類別佈建 TPU，並部署工作負載，請完成下列步驟：

  1. 將下列資訊清單儲存為 tpu-compute-class.yaml：

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: tpu-class
spec:
  priorities:
  - tpu:
      type: tpu-v5-lite-podslice
      count: 4
      topology: 2x4
  - spot: true
    tpu:
      type: tpu-v5-lite-podslice
      count: 4
      topology: 2x4
  - flexStart:
      enabled: true
    tpu:
      type: tpu-v6e-slice
      count: 4
      topology: 2x4
  nodePoolAutoCreation:
    enabled: true

  2. 部署運算類別：

    kubectl apply -f tpu-compute-class.yaml

    如要進一步瞭解自訂運算類別和 TPU，請參閱 TPU 設定。

  3. 將下列資訊清單儲存為 tpu-job.yaml：

    apiVersion: v1
kind: Service
metadata:
  name: headless-svc
spec:
  clusterIP: None
  selector:
    job-name: tpu-job
---
apiVersion: batch/v1
kind: Job
metadata:
  name: tpu-job
spec:
  backoffLimit: 0
  completions: 4
  parallelism: 4
  completionMode: Indexed
  template:
    spec:
      subdomain: headless-svc
      restartPolicy: Never
      nodeSelector:
        cloud.google.com/compute-class: tpu-class
      containers:
      - name: tpu-job
        image: python:3.10
        ports:
        - containerPort: 8471 # Default port using which TPU VMs communicate
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        command:
        - bash
        - -c
        - |
          pip install 'jax[tpu]' -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
          python -c 'import jax; print("TPU cores:", jax.device_count())'
        resources:
          requests:
            cpu: 10
            memory: MEMORY_SIZE
            google.com/tpu: NUMBER_OF_CHIPS
          limits:
            cpu: 10
            memory: MEMORY_SIZE
            google.com/tpu: NUMBER_OF_CHIPS

    更改下列內容：

    • NUMBER_OF_CHIPS：供容器使用的 TPU 晶片數量。limits 和 requests 的值必須相同，且等於所選自訂運算類別中 tpu.count 欄位的值。
    • MEMORY_SIZE：TPU 使用的記憶體量上限。記憶體限制取決於您使用的 TPU 版本和拓撲。詳情請參閱「加速器的最低和最高值」。
    • NUMBER_OF_CHIPS：供容器使用的 TPU 晶片數量。limits 和 requests 的值必須相同。

  4. 部署 Job：

    kubectl create -f tpu-job.yaml

    建立這項 Job 時，GKE 會自動執行下列操作：

    • 佈建節點來執行 Pod。視您指定的 TPU 類型、拓撲和資源要求而定，這些節點可以是單一主機配量或多主機配量。視最高優先順序的 TPU 資源可用性而定，GKE 可能會改用較低的優先順序，盡量取得資源。
    • 在 Pod 中新增 taint，並在節點中新增容許條件，防止其他工作負載與 TPU 工作負載在相同節點上執行。

    詳情請參閱「關於自訂運算類別」。

  5. 完成本節後，您可以刪除已建立的資源，避免繼續計費：

    kubectl delete -f tpu-job.yaml

設定 TPU 節點自動修復功能

如果多主機 TPU 配量節點集區中的 TPU 配量節點不健康，系統會重新建立整個節點集區。而在單一主機 TPU 配量節點集區中，系統只會自動修復狀況不良的 TPU 節點。

導致 TPU 配量節點狀況不良的條件包括：

  • 任何具有常見節點條件的 TPU 配量節點。
  • 任何 TPU 配量節點，其無法分配的 TPU 數量大於零。
  • TPU 節點中任何停止 (因先占) 或終止的 VM 執行個體。
  • 節點維護：如果多主機 TPU 配量節點集區中的任何 TPU 配量節點因主機維護而停機，GKE 會重新建立整個 TPU 配量節點集區。

你可以在作業記錄中查看維修狀態 (包括失敗原因)。如果失敗原因是配額不足，請與Google Cloud 帳戶代表聯絡，要求增加相應配額。

為 TPU 節點設定正常終止

在控制層執行 1.29.1-gke.1425000 以上版本的 GKE 叢集中，TPU 配量節點支援 SIGTERM 訊號，可提醒節點即將關機。在 TPU 節點中，即將關機的通知最多可設定為五分鐘。

如要設定 GKE 在這段通知時間內正常終止工作負載，請按照「管理 GPU 和 TPU 的 GKE 節點中斷」一文中的步驟操作。

在非特權模式下執行容器

在 GKE 1.28 以上版本中，節點執行的容器不需要啟用特殊權限模式，即可存取 TPU。GKE 1.28 版以前的節點需要使用具備權限的模式。

如果 TPU 節點執行的是低於 1.28 的版本，請參閱下列章節：

在 TPU 配量中的 VM 上執行的容器需要存取鎖定記憶體的較高限制，因此驅動程式可以透過直接記憶體存取 (DMA) 與 TPU 晶片通訊。如要啟用這項功能，必須設定較高的 ulimit。如要縮減容器的權限範圍，請完成下列步驟：

  1. 編輯 securityContext，加入下列欄位：

    securityContext:
  capabilities:
    add: ["SYS_RESOURCE"]

  2. 在容器內執行下列指令，增加 ulimit，然後設定工作負載以使用 TPU 資源：

    ulimit -l 68719476736

如要使用 TPU v5e，請在 1.27.4-gke.900 以上版本的叢集中，執行不含特殊權限模式的容器。

觀測能力和指標

資訊主頁

Google Cloud 控制台中的節點集區可觀測性功能現已全面開放使用。 如要查看 GKE 中 TPU 多主機節點集區的狀態，請前往 Cloud Monitoring 提供的 GKE TPU 節點集區狀態資訊主頁：

前往 GKE TPU 節點集區狀態

這個資訊主頁可提供多主機 TPU 節點集區的健康狀態深入分析。 詳情請參閱「監控 TPU 節點和節點集區的健康狀態指標」。

在Google Cloud 控制台的「Kubernetes Clusters」頁面中，「Observability」分頁標籤也會顯示 TPU 可觀測性指標，例如「Accelerators > TPU」標題下的 TPU 使用率。詳情請參閱「查看可觀測性指標」。

只有在 GKE 叢集中啟用系統指標，TPU 資訊主頁才會顯示資料。

執行階段指標

0.4.14您可以在 Cloud Monitoring 中使用下列指標，監控 TPU 工作負載的執行階段效能：

  • 任務週期：在過去取樣期間 (60 秒) 內，TensorCore 在 TPU 晶片上積極處理作業的時間百分比。百分比越高，表示 TPU 使用率越高。
  • 已用記憶體：分配的加速器記憶體量，以位元組為單位。每 60 秒取樣一次。
  • 記憶體總量：加速器記憶體總量，以位元組為單位。每 60 秒取樣一次。

這些指標位於 Kubernetes 節點 (k8s_node) 和 Kubernetes 容器 (k8s_container) 架構中。

Kubernetes 容器：

  • kubernetes.io/container/accelerator/duty_cycle
  • kubernetes.io/container/accelerator/memory_used
  • kubernetes.io/container/accelerator/memory_total

Kubernetes 節點：

  • kubernetes.io/node/accelerator/duty_cycle
  • kubernetes.io/node/accelerator/memory_used
  • kubernetes.io/node/accelerator/memory_total

監控 TPU 節點和節點集區的健康狀態指標

如果訓練工作發生錯誤或終止失敗，您可以檢查基礎架構相關指標，判斷中斷是否是由基礎節點或節點集區的問題所導致。

節點狀態

在 1.32.1-gke.1357001 以上版本的 GKE 中，下列 GKE 系統指標會公開 GKE 節點的狀態：

  • kubernetes.io/node/status_condition

condition 欄位會回報節點的狀況，例如 Ready、DiskPressure 和 MemoryPressure。status 欄位會顯示回報的狀況狀態，可能為 True、False 或 Unknown。這是具有 k8s_node 受控資源類型的指標。

這項 PromQL 查詢會顯示特定節點是否為 Ready：

kubernetes_io:node_status_condition{
    monitored_resource="k8s_node",
    cluster_name="CLUSTER_NAME",
    node_name="NODE_NAME",
    condition="Ready",
    status="True"}

如要協助排解叢集問題，您可能需要查看出現其他狀況的節點：

kubernetes_io:node_status_condition{
    monitored_resource="k8s_node",
    cluster_name="CLUSTER_NAME",
    condition!="Ready",
    status="True"}

您可能想特別查看以下節點：Ready

kubernetes_io:node_status_condition{
    monitored_resource="k8s_node",
    cluster_name="CLUSTER_NAME",
    condition="Ready",
    status="False"}

如果沒有資料，節點就已準備就緒。系統每 60 秒會取樣一次狀態條件。

您可以使用下列查詢，瞭解整個車隊的節點狀態：

avg by (condition,status)(
  avg_over_time(
    kubernetes_io:node_status_condition{monitored_resource="k8s_node"}[${__interval}]))

節點集區狀態

下列 GKE 系統指標適用於 k8s_node_pool 受監控資源，可顯示 GKE 節點集區的狀態：

  • kubernetes.io/node_pool/status

這項指標只會回報給多主機 TPU 節點集區。

status 欄位會回報節點集區的狀態，例如 Provisioning、Running、Error、Reconciling 或 Stopping。狀態會在 GKE API 作業完成後更新。

如要確認特定節點集區是否處於 Running 狀態，請使用下列 PromQL 查詢：

kubernetes_io:node_pool_status{
    monitored_resource="k8s_node_pool",
    cluster_name="CLUSTER_NAME",
    node_pool_name="NODE_POOL_NAME",
    status="Running"}

如要監控專案中節點集區的數量 (依狀態分組)，請使用下列 PromQL 查詢：

count by (status)(
  count_over_time(
    kubernetes_io:node_pool_status{monitored_resource="k8s_node_pool"}[${__interval}]))

節點集區可用性

下列 GKE 系統指標會顯示多主機 TPU 節點集區是否可用：

  • kubernetes.io/node_pool/multi_host/available

如果節點集區中的所有節點均可使用，指標值為 True，否則為 False。系統每 60 秒就會對指標進行一次取樣。

如要查看專案中多主機 TPU 節點集區的可用性，請使用下列 PromQL 查詢：

avg by (node_pool_name)(
  avg_over_time(
    kubernetes_io:node_pool_multi_host_available{
      monitored_resource="k8s_node_pool",
      cluster_name="CLUSTER_NAME"}[${__interval}]))

節點中斷次數

下列 GKE 系統指標會回報自上次取樣以來，GKE 節點的中斷次數 (指標每 60 秒取樣一次)：

  • kubernetes.io/node/interruption_count

interruption_type (例如 TerminationEvent、MaintenanceEvent 或 PreemptionEvent) 和 interruption_reason (例如 HostError、Eviction 或 AutoRepair) 欄位可協助提供節點中斷的原因。

如要取得專案中叢集內 TPU 節點的中斷情形和原因明細，請使用下列 PromQL 查詢：

  sum by (interruption_type,interruption_reason)(
    sum_over_time(
      kubernetes_io:node_interruption_count{monitored_resource="k8s_node"}[${__interval}]))

如要只查看主機維護事件，請更新查詢，篩選 interruption_reason 的 HW/SW Maintenance 值。使用下列 PromQL 查詢：

```promql
sum by (interruption_type,interruption_reason)(
  sum_over_time(
kubernetes_io:node_interruption_count{monitored_resource="k8s_node", interruption_reason="HW/SW Maintenance"}[${__interval}]))
```

如要查看依節點集區匯總的中斷次數，請使用下列 PromQL 查詢：

```promql
sum by (node_pool_name,interruption_type,interruption_reason)(
  sum_over_time(
    kubernetes_io:node_pool_interruption_count{monitored_resource="k8s_node_pool", interruption_reason="HW/SW Maintenance", node_pool_name=NODE_POOL_NAME }[${__interval}]))
```

節點集區復原時間 (TTR)

下列 GKE 系統指標會回報 GKE 多主機 TPU 節點集區的復原期長度分布情形：

  • kubernetes.io/node_pool/accelerator/times_to_recover

這項指標中記錄的每個樣本，都代表節點集區從停機期間復原的單一事件。

這項指標有助於追蹤多主機 TPU 節點集區的復原時間和中斷間隔時間。

您可以使用下列 PromQL 查詢，計算叢集過去 7 天的平均修復時間 (MTTR)：

sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_to_recover_sum{
    monitored_resource="k8s_node_pool", cluster_name="CLUSTER_NAME"}[7d]))
/
sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_to_recover_count{
    monitored_resource="k8s_node_pool",cluster_name="CLUSTER_NAME"}[7d]))

節點集區中斷情形間隔時間 (TBI)

節點集區中斷情形間隔時間會衡量基礎架構在發生中斷情形前運作的時間長度。 計算方式是取一段時間內的平均值，分子是基礎架構的總運作時間，分母是基礎架構的總中斷次數。

下列 PromQL 範例顯示指定叢集的 7 天中斷情形平均間隔時間 (MTBI)：

sum(count_over_time(
  kubernetes_io:node_memory_total_bytes{
    monitored_resource="k8s_node", node_name=~"gke-tpu.*|gk3-tpu.*", cluster_name="CLUSTER_NAME"}[7d]))
/
sum(sum_over_time(
  kubernetes_io:node_interruption_count{
    monitored_resource="k8s_node", node_name=~"gke-tpu.*|gk3-tpu.*", cluster_name="CLUSTER_NAME"}[7d]))

主機指標

在 GKE 1.28.1-gke.1066000 以上版本中，TPU 節點中的 VM 會將 TPU 使用率指標匯出為 GKE 系統指標。您可以在 Cloud Monitoring 中使用下列指標，監控 TPU 主機的效能：

  • TensorCore 使用率：目前 TensorCore 的使用率。TensorCore 值等於矩陣乘法單元 (MXU) 加上向量單元的總和。 TensorCore 使用率值是將過去取樣期間 (60 秒) 執行的 TensorCore 作業數量，除以相同期間支援的 TensorCore 作業數量。值越大代表使用率越高。
  • 記憶體頻寬使用率：目前使用的加速器記憶體頻寬百分比。將取樣期間 (60 秒) 內使用的記憶體頻寬，除以相同取樣期間內支援的最大頻寬，即可得出這項指標。

這些指標位於 Kubernetes 節點 (k8s_node) 和 Kubernetes 容器 (k8s_container) 架構中。

Kubernetes 容器：

  • kubernetes.io/container/accelerator/tensorcore_utilization
  • kubernetes.io/container/accelerator/memory_bandwidth_utilization

Kubernetes 節點：

  • kubernetes.io/node/accelerator/tensorcore_utilization
  • kubernetes.io/node/accelerator/memory_bandwidth_utilization

詳情請參閱「Kubernetes 指標」和「GKE 系統指標」。

已知問題

  • 在新的 TPU 節點回報可用 TPU 之前，叢集自動配置器可能會錯誤計算這些節點的容量。叢集自動調度器可能會執行額外的向上擴充作業，因此建立的節點會超出需求。在一般縮減作業後，叢集自動調度器會縮減不需要的額外節點。
  • 如果 TPU 節點集區處於等待狀態超過 10 小時，叢集自動調度器就會取消擴充作業。叢集自動配置器稍後會重試這類向上擴充作業。這項行為可能會降低未使用預留項目的客戶取得 TPU 的機率。
  • 如果非 TPU 工作負載容許 TPU 汙點，且在排空 TPU 配量節點集區期間重新建立，則可能會阻止節點集區縮減。
  • v5e TPU 不提供記憶體頻寬使用率指標。

後續步驟