在 GKE Standard 部署 TPU 工作負載

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

本教學課程適用於機器學習 (ML) 工程師、平台管理員和操作員,適合想瞭解如何使用 Kubernetes 容器自動化調度管理功能,透過 TPU 管理大規模模型訓練、微調和推論工作負載的人員。如要進一步瞭解 Google Cloud 內容中提及的常見角色和工作範例,請參閱「常見的 GKE 使用者角色和工作」。

閱讀本頁面之前,請務必熟悉下列內容:

事前準備

開始之前,請確認您已執行下列工作:

  • 啟用 Google Kubernetes Engine API。
  • 啟用 Google Kubernetes Engine API
  • 如要使用 Google Cloud CLI 執行這項工作,請安裝並初始化 gcloud CLI。如果您先前已安裝 gcloud CLI,請執行 gcloud components update 指令,取得最新版本。較舊的 gcloud CLI 版本可能不支援執行本文中的指令。

規劃 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 控制台的「Quotas」(配額) 頁面:

    前往配額頁面

  2. 在「 Filter」(篩選器) 方塊中,執行下列操作:

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

      TPU 版本、機器類型開頭 隨需執行個體配額的屬性和名稱 Spot2 執行個體的配額屬性和名稱
      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
      Ironwood (TPU7x),
      tpu7x-standard-4t
      Dimensions (e.g. location):
      tpu_family:tpu7x
      Name:
      Preemptible TPU slices tpu7x
    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 配額的「Limit」(限制) 和「Current usage」(目前用量) 都會增加 16。

  1. 建立 TPU 切片節點集區時,請使用 --reservation 和 --reservation-affinity=specific 旗標建立預留執行個體。購買承諾使用合約時,可預留 TPU。↩

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

其他 GKE 資源的配額

在 GKE 建立資源的區域中,您可能需要提高下列 GKE 相關配額。

  • Persistent Disk SSD (GB) 配額:每個 Kubernetes 節點的開機磁碟預設需要 100 GB。因此,這項配額至少應設為預計建立的 GKE 節點數量上限乘以 100 GB (節點 * 100 GB)。
  • 使用中的 IP 位址配額:每個 Kubernetes 節點會耗用一個 IP 位址。因此,這項配額至少應設為您預計建立的 GKE 節點數量上限。
  • 確保 max-pods-per-node 與子網路範圍一致:每個 Kubernetes 節點都會使用 Pod 的次要 IP 範圍。舉例來說,如果 max-pods-per-node 為 32,則需要 64 個 IP 位址,也就是每個節點需要 /26 子網路。請注意,這個範圍不應與任何其他叢集共用。為避免 IP 位址範圍用盡,請使用 --max-pods-per-node 旗標,限制可在節點上排定的 Pod 數量。max-pods-per-node 的配額至少應設為您預計建立的 GKE 節點數量上限。

如要申請提高配額,請參閱「要求調整配額」。

確保預留項目可用

如要使用預留項目建立 TPU 配量節點集區,預留項目必須在建立節點集區時,有足夠的可用 TPU 晶片。

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

建立叢集

gcloud

在有 TPU 的區域中,以標準模式建立 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 可用性」。

Cluster Toolkit

  1. 設定 Cluster Toolkit。
  2. 使用 Cluster Toolkit 藍圖 (例如 gke-tpu-v6e 或 gke-tpu-7x;如需 TPU v4、v5e 和 v5p 藍圖,請參閱 Cluster Toolkit GitHub 存放區) 部署 GKE TPU 叢集:

    gcluster deploy examples/gke-tpu-7x/gke-tpu-7x.yaml \
      --vars project_id=PROJECT_ID,deployment_name=DEPLOYMENT_NAME,zone=ZONE
    

    更改下列內容:

    • DEPLOYMENT_NAME:Cluster Toolkit 部署作業的名稱 (也是 GKE 叢集的名稱)。
    • PROJECT_ID:您的 Google Cloud 專案 ID。
    • ZONE:根據您要使用的 TPU 版本,指定可用區名稱。如要找出可用的位置,請參閱「GKE 中的 TPU 可用性」。如要使用預留容量,請務必使用預留容量所在的可用區。

您已建立 GKE 叢集,其節點集區包含指定的 TPU 資源。現在可以按照本文件「在 TPU slice 節點上執行工作負載」一節中的步驟操作。

佈建 TPU

如要在 GKE 中佈建 TPU,您可以使用下列設定選項:
  • 手動建立節點集區:您可以建立具有特定 TPU 版本和拓撲的節點集區。
  • 使用 GKE 自動佈建節點:您可以在叢集層級啟用自動佈建節點,然後在 Pod 的資訊清單中,使用 nodeSelector 指定 TPU 版本和拓撲。當待處理的 Pod 符合這些選取器時,GKE 會自動建立符合要求的新節點集區。這個方法需要您為 TPU 設定叢集層級的資源限制。
  • 定義自訂 ComputeClass:您可以使用自訂 ComputeClass 要求 TPU。平台管理員可以透過自訂 ComputeClass,定義節點設定階層,讓 GKE 在決定節點資源調度時優先考量,確保工作負載在所選硬體上執行。

手動建立節點集區

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

建立單一主機 TPU 配量節點集區

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

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 建立節點集區的可用區。

    選用:使用 AI 專區,例如 us-central1-ai1a。AI 可用區是專門用於 AI/機器學習工作負載的 Google Cloud 區域。

  • MACHINE_TYPE:TPU 版本和類型。例如,Ironwood (TPU7x) 請使用 tpu7x-standard-4t。

您也可以視需要使用下列旗標:

  • --num-nodes=NUM_NODES:各可用區節點集區中的初始節點數量。

    最佳做法:

    如果您對節點集區使用 enable-autoscaling 旗標,請將 num-nodes 設為 0,這樣自動配置器就會在工作負載需要時,立即佈建額外節點。

  • --reservation=RESERVATION_NAME:GKE 建立節點集區時使用的預留項目名稱。如果省略這個旗標,GKE 會使用可用的 TPU。如要進一步瞭解 TPU 預留項目,請參閱「關於 Cloud TPU 預留項目」。

  • --node-labels cloud.google.com/gke-workload-type=HIGH_AVAILABILITY:告知 GKE,單一主機 TPU slice 節點集區是集合的一部分。如果符合下列條件,請使用這個標記:

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

    如要進一步瞭解收集排程管理,請參閱「管理單一主機 TPU Slice 的收集排程」。

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

    • --total-min-nodes=TOTAL_MIN_NODES:節點集區中所有節點的數量下限。
    • --total-max-nodes=TOTAL_MAX_NODES:節點集區中所有節點的數量上限。
    • --location-policy=ANY:優先使用未使用的預留項目,並降低 Spot VM 的先占風險。
  • --spot:將節點集區設為使用 Spot VM 做為節點集區中的節點。節點集區建立後即無法變更。

  • --flex-start:將節點集區設為使用彈性啟動型 VM。建立彈性啟動型 VM 時,請使用彈性啟動用量方案。詳情請參閱「使用 TPU 和彈性啟動 VM 執行小型批次工作負載」。

如需可指定的完整旗標清單,請參閱 gcloud container clusters create 參考資料。

Terraform

  1. 請務必使用 4.84.0 以上版本的 google 供應商。
  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 建立節點集區的可用區。

    選用:使用 AI 專區,例如 us-central1-ai1a。AI 可用區是專門用於 AI/機器學習工作負載的 Google Cloud 區域。

  • MACHINE_TYPE:要使用的 TPU 機器類型。如要查看與 TPU 相容的機型,請參閱「選擇 TPU 版本」中的表格。

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

  • autoscaling:建立已啟用自動調度資源功能的節點集區。如果是單一主機 TPU 切片,GKE 會在 TOTAL_MIN_NODES 和 TOTAL_MAX_NODES 值之間調度資源。
    • TOTAL_MIN_NODES:節點集區中所有節點的數量下限。除非同時指定自動調度資源,否則這個欄位為選填。
    • TOTAL_MAX_NODES:節點集區中所有節點的數量上限。除非同時指定自動調度資源,否則這個欄位為選填。
  • RESERVATION_NAME:如果您使用 Cloud TPU 預留項目,則這是建立節點集區時要使用的預留資源標籤清單。如要進一步瞭解如何在 reservation_affinity 欄位中填入 RESERVATION_LABEL_VALUES,請參閱「Terraform 供應商」。
  • spot:將節點集區設為使用 TPU 節點的 Spot VM。節點集區建立後即無法變更。詳情請參閱「Spot VM」。
  • flex_start:將節點集區設為使用 彈性啟動 用量方案。如果已啟用 spot,則無法設為 true。GKE 1.33.0-gke.1712000 以上版本支援彈性啟動功能。

控制台

如要建立含有 TPU 的節點集區,請按照下列步驟操作:

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

    前往「Google Kubernetes Engine」

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

  3. 按一下「Nodes」(節點) 分頁標籤。

  4. 按一下「 建立由使用者自行管理的節點集區」。

  5. 在「Node pool details」(節點集區詳細資料) 部分,勾選「Specify node locations」(指定節點位置) 方塊。

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

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

  8. 在「機器設定」部分,選取「TPU」。

  9. 在「系列」下拉式選單中,選取下列其中一項:

    • CT3:TPU v3,單主機裝置
    • CT3P:TPU v3,多主機 Pod 配量
    • CT4P:TPU v4
    • CT5LP:TPU v5e
    • CT5P:TPU v5p
    • CT6E:TPU Trillium (v6e)
  10. 在「Machine type」(機器類型) 下拉式選單中,選取要用於節點的機器名稱。請參閱「選擇 TPU 版本」表格,瞭解如何定義機器類型和 TPU 拓撲,以建立單一主機 TPU 配量節點集區。

  11. 在「TPU Topology」(TPU 拓撲) 下拉式選單中,選取 TPU 切片的實體拓撲。

  12. 在「需要變更」對話方塊中,按一下「執行變更」。

  13. 確認「Boot disk type」(開機磁碟類型) 為「Standard persistent disk」(標準永久磁碟) 或「SSD persistent disk」(SSD 永久磁碟)。

  14. (選用) 勾選「Enable nodes on spot VMs」(啟用 Spot VM 上的節點) 核取方塊,即可在節點集區中,將 Spot VM 用於節點。

  15. 點選「建立」。

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

建立多主機 TPU 配量節點集區的步驟,會因您使用的是 Ironwood (TPU7x) 或更早的 TPU 版本而異。

Ironwood (TPU7x)

您可以使用 Google Cloud CLI 或 Terraform,在 Ironwood (TPU7x) 版本中建立多主機 TPU slice 節點集區:

gcloud

如要使用 Ironwood (TPU7x) 建立多主機 TPU 配量節點集區,必須先建立工作負載政策。

  1. 建立工作負載政策:

    gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
        --type=HIGH_THROUGHPUT \
        --accelerator-topology=TPU_TOPOLOGY \
        --project=PROJECT_ID \
        --region=REGION
    

    更改下列內容:

    • WORKLOAD_POLICY_NAME:工作負載政策的名稱。
    • TPU_TOPOLOGY:TPU Ironwood (TPU7x) 拓撲。例如,2x2x2。如要查看所有支援的 Ironwood (TPU7x) 拓撲,請參閱拓撲一節。
    • PROJECT_ID:您的 Google Cloud 專案 ID。
    • REGION:工作負載政策的區域。工作負載政策是區域性資源,可重複用於拓撲相同的節點集區。
  2. 使用工作負載政策建立節點集區:

    gcloud container node-pools create NODE_POOL_NAME \
      --cluster=CLUSTER_NAME \
      --machine-type=tpu7x-standard-4t \
      --placement-policy=WORKLOAD_POLICY_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --node-locations=NODE_ZONE \
      --project=PROJECT_ID \
      --reservation=RESERVATION_NAME \
      --reservation-affinity=specific
    

    更改下列內容:

    • NODE_POOL_NAME:新節點集區的名稱。
    • CLUSTER_NAME:GKE 叢集名稱。
    • WORKLOAD_POLICY_NAME:您建立的工作負載政策名稱。
    • CONTROL_PLANE_LOCATION:叢集控制層的 Compute Engine 位置。提供區域叢集的區域,或可用區叢集的可用區。
    • NODE_ZONE:根據要使用的 TPU 版本,指定可用區名稱。

      選用:使用 AI 專區,例如 us-central1-ai1a。AI 可用區是專門用於 AI/機器學習工作負載的 Google Cloud 區域。

      如要找出可用的位置,請參閱「GKE 中的 TPU 可用性」。
    • PROJECT_ID:您的 Google Cloud 專案 ID。
    • RESERVATION_NAME:要使用的預留項目名稱。

    在這個指令中,--tpu-topology 旗標已替換為 --placement-policy 旗標。

Terraform

  1. 請務必使用 4.84.0 以上版本的 google 供應商。
  2. 建立工作負載政策:

    resource "google_compute_resource_policy" {
      name   = "WORKLOAD_POLICY_NAME"
      region = CLUSTER_LOCATION
      workload_policy {
        type = "HIGH_THROUGHPUT"
        accelerator_topology = "TPU_TOPOLOGY"
      }
    }
    

    更改下列內容:

    • WORKLOAD_POLICY_NAME:工作負載政策的名稱。
    • CLUSTER_LOCATION:叢集的運算位置。建議您使用區域叢集,提高 Kubernetes 控制層的可靠性。您也可以使用可用區叢集。詳情請參閱「選取 TPU 版本和拓撲」。
    • TPU_TOPOLOGY:TPU Ironwood (TPU7x) 拓撲。例如,2x2x2。如要查看所有支援的 Ironwood (TPU7x) 拓撲,請參閱「規劃 TPU」。

    如要進一步瞭解 google_compute_resource_policy 參考資料,請參閱「Terraform Provider」。

  3. 在 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]
        }
        flex_start = false
        spot = true
      }
    
      placement_policy {
        policy_name = WORKLOAD_POLICY_NAME
      }
    }
    

    更改下列內容:

    • NODE_POOL_RESOURCE_NAME:Terraform 範本中的節點集區資源名稱。
    • PROJECT_ID:您的專案 ID。
    • CLUSTER_NAME:要新增節點集區的現有叢集名稱。
    • POOL_NAME:要建立的節點集區名稱。
    • NODE_ZONES:以半形逗號分隔的清單,列出一或多個 GKE 建立節點集區的可用區。

      選用:使用 AI 專區,例如 us-central1-ai1a。AI 可用區是專門用於 AI/機器學習工作負載的 Google Cloud 區域。

    • NUM_NODES:節點集區中的節點數量。這個值必須為零,或是 TPU 晶片數量除以四的乘積,因為在多主機 TPU 配量中,每個 TPU 配量節點都有四個晶片。舉例來說,如果 TPU_TOPOLOGY 為 4x8,則有 32 個晶片,這表示 NUM_NODES 必須為 8。如要進一步瞭解 TPU 拓撲,請參閱「選擇 TPU 版本」中的表格。
    • TPU_TOPOLOGY:表示為 TPU 切片選取的實體拓撲。拓撲格式取決於您使用的 TPU 版本。如要進一步瞭解 TPU 拓撲,請參閱「選擇拓撲」中的表格。

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

    • RESERVATION_NAME:如果使用 TPU 預留項目,請提供建立節點集區時要使用的預留項目資源標籤清單。如要進一步瞭解如何在 reservation_affinity 欄位中填入 RESERVATION_LABEL_VALUES,請參閱「Terraform Provider」。
    • autoscaling:建立已啟用自動調度資源功能的節點集區。GKE 縮放多主機 TPU 配量節點集區時,會不可分割地將節點集區從零擴充至大小上限。
      • MAX_NODES:節點集區的大小上限。這個值必須等於 TPU_TOPOLOGY ({A}x{B}x{C}) 中定義的值乘積,除以每個 VM 中的晶片數量。舉例來說,如果 TPU_TOPOLOGY 為 2x2x2,則乘積為 8。tpu7x-standard-4t 中的每個 VM 都有 4 個晶片,因此節點數量為 2。
    • spot:將使用 Spot VM 做為 TPU 切片節點的節點集區。節點集區建立後即無法變更這項設定。詳情請參閱「Spot VM」。
    • flex_start:要使用 彈性啟動 用量方案的節點集區。如果已啟用 spot,這項設定就無法設為 true。

其他 TPU 版本

您可以使用 Google Cloud CLI、Terraform 或 Google Cloud 控制台,在 v3、v4、v5p、v5e 和 Trillium (v6e) 版本中建立多主機 TPU 切片節點集區。

gcloud

  gcloud container node-pools create POOL_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --cluster=CLUSTER_NAME \
      --node-locations=NODE_ZONE \
      --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:新節點集區的名稱。
  • CONTROL_PLANE_LOCATION:根據您要使用的 TPU 版本,指定可用區名稱。如要找出可用的位置,請參閱「GKE 中的 TPU 可用性」。
  • CLUSTER_NAME:叢集名稱。
  • NODE_ZONES:以半形逗號分隔的清單,列出一或多個 GKE 建立節點集區的可用區。

    選用:使用 AI 專區,例如 us-central1-ai1a。AI 可用區是專門用於 AI/機器學習工作負載的 Google Cloud 區域。

  • 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:將節點集區設為使用彈性啟動型 VM。彈性啟動型 VM 是使用彈性啟動用量方案建立,GKE 1.33.0-gke.1712000 以上版本支援這項功能。

  • --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 Slice 的收集排程」。

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

Terraform

  1. 請務必使用 4.84.0 以上版本的 google 供應商。
  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]
        }
        flex_start = false
        spot = true
      }
    
      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 建立節點集區的可用區。

      選用:使用 AI 專區,例如 us-central1-ai1a。AI 可用區是專門用於 AI/機器學習工作負載的 Google Cloud 區域。

    • 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 Provider」。
    • 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. 按一下「Nodes」(節點) 分頁標籤。

  4. 按一下「 建立由使用者自行管理的節點集區」。

  5. 在「Node pool details」(節點集區詳細資料) 部分,勾選「Specify node locations」(指定節點位置) 方塊。

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

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

  8. 在「機器設定」部分,選取「TPU」。

  9. 在「系列」下拉式選單中,選取下列其中一項:

    • CT3:TPU v3,單主機裝置
    • CT3P:TPU v3,多主機 Pod 配量
    • CT4P:TPU v4
    • CT5LP:TPU v5e
    • CT5P:TPU v5p
    • CT6E:TPU Trillium (v6e)
  10. 在「Machine type」(機器類型) 下拉式選單中,選取要用於節點的機器名稱。請參閱「選擇 TPU 版本」表格,瞭解如何定義機器類型和 TPU 拓撲,建立多主機 TPU 配量節點集區。

  11. 在「TPU Topology」(TPU 拓撲) 下拉式選單中,選取 TPU 切片的實體拓撲。

  12. 在「需要變更」對話方塊中,按一下「執行變更」。

  13. 確認「Boot disk type」(開機磁碟類型) 為「Standard persistent disk」(標準永久磁碟) 或「SSD persistent disk」(SSD 永久磁碟)。

  14. (選用) 勾選「Enable nodes on spot VMs」(啟用 Spot VM 上的節點) 核取方塊,即可在節點集區中的節點使用 Spot VM。

  15. 點選「建立」。

使用 GKE 自動佈建節點功能

您可以設定 GKE 自動建立及刪除節點集區,滿足 TPU 工作負載的資源需求。

  1. 如要啟用節點集區自動佈建功能,請編輯叢集 TPU 資源限制:

      gcloud container clusters update CLUSTER_NAME \
          --location=CONTROL_PLANE_LOCATION \
          --enable-autoprovisioning \
          --min-cpu=MINIMUM_CPU \
          --min-memory=MINIMUM_MEMORY \
          --max-cpu=MAXIMUM_CPU \
          --max-memory=MAXIMUM_MEMORY \
          --min-accelerator=type=TPU_TYPE,count=MINIMUM_TPU_COUNT \
          --max-accelerator=type=TPU_TYPE,count=MAXIMUM_TPU_COUNT
    

    更改下列內容:

    • TPU_TYPE:TPU 類型。例如,Ironwood (TPU7x) 請使用 tpu7x。
    • MINIMUM_TPU_COUNT:叢集可擁有的指定類型 TPU 晶片數量下限。如果您指定的值大於多主機 TPU 配量中的 TPU 晶片數量,GKE 會移除配量中的所有節點。多主機節點集區的資源調度範圍介於 0 到切片中的節點數量之間,沒有中間值。
    • MAXIMUM_TPU_COUNT:叢集可擁有的指定類型 TPU 晶片數量上限。如果是多主機 TPU 切片,請指定大於每個切片中晶片數量的值,讓 GKE 能以不可分割的方式調度切片資源。配量中的晶片數量是 TPU 拓撲的乘積。舉例來說,如果拓撲為 2x2x2,則切片中的晶片數量為 8,這表示 MAXIMUM_TPU_COUNT 的值必須大於 8。

定義自訂 ComputeClass

您也可以使用自訂 ComputeClass,設定 GKE 在建立新節點的資源調度作業中要求 TPU。

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

以下各節說明如何建立自訂 ComputeClass,然後建立工作,使用 ComputeClass 中定義的 TPU。

建立自訂 ComputeClass

建立符合 TPU 規則的自訂 ComputeClass 時,步驟會因您使用的是 Ironwood (TPU7x) 或較早的 TPU 版本而有所不同。

Ironwood (TPU7x)

  1. 建立工作負載政策。只有在建立多主機節點集區時,才需要執行這個步驟,具體取決於您選擇的拓撲。如果您使用單一主機節點集區,請略過這個步驟。

    gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
        --type=HIGH_THROUGHPUT \
        --accelerator-topology=TPU_TOPOLOGY \
        --project=PROJECT_ID \
        --region=REGION
    

    更改下列內容:

    • WORKLOAD_POLICY_NAME:工作負載政策的名稱。
    • TPU_TOPOLOGY:TPU Ironwood (TPU7x) 拓撲。例如,使用 2x2x2。如要進一步瞭解所有支援的 Ironwood (TPU7x) 拓撲,請參閱拓撲一節。
    • PROJECT_ID: Google Cloud 專案 ID。
    • REGION:工作負載政策的區域。工作負載政策是區域性資源,可跨節點集區使用。
  2. 將下列資訊清單儲存為 tpu-compute-class.yaml:

    apiVersion: cloud.google.com/v1
    kind: ComputeClass
    metadata:
      name: tpu-class
    spec:
      priorities:
        - tpu:
            type: tpu7x
            topology: TPU_TOPOLOGY
            count: 4
          placement:
            policyName: WORKLOAD_POLICY_NAME
      nodePoolAutoCreation:
        enabled: true
    
  3. (選用) 您可以使用特定預留項目或子區塊。舉例來說,您可以在 ComputeClass 資訊清單中加入下列 specs:

      reservations:
        affinity: Specific
        specific:
          - name: RESERVATION_NAME
            reservationBlock:
              name: RESERVATION_BLOCK_NAME
              reservationSubBlock:
                name: RESERVATION_SUB_BLOCK_NAME
    

    更改下列內容:

    • RESERVATION_NAME:Compute Engine 預留容量的名稱。
    • RESERVATION_BLOCK_NAME:Compute Engine 預留容量區塊的名稱。
    • RESERVATION_SUB_BLOCK_NAME:Compute Engine 預留容量子區塊的名稱。

    詳情請參閱「使用預留的可用區資源」。

其他 TPU 版本

如要使用為 TPU 設定的自訂 ComputeClass,佈建 v3、v4、v5p、v5e 或 v6e (Trillium) TPU,請完成下列步驟:

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

    apiVersion: cloud.google.com/v1
    kind: ComputeClass
    metadata:
      name: tpu-class
    spec:
      priorities:
      - tpu:
          type: TPU_TYPE
          count: NUMBER_OF_CHIPS
          topology: TOPOLOGY
      - spot: true
        tpu:
          type: TPU_TYPE
          count: NUMBER_OF_CHIPS
          topology: TOPOLOGY
      - flexStart:
          enabled: true
        tpu:
          type: TPU_TYPE
          count: NUMBER_OF_CHIPS
          topology: TOPOLOGY
      nodePoolAutoCreation:
        enabled: true
    

    更改下列內容:

    • TPU_TYPE:要使用的 TPU 類型,例如 tpu-v4-podslice。必須是 GKE 支援的值。
    • TOPOLOGY:配量中 TPU 晶片的排列方式,例如 2x2x4。必須是所選 TPU 類型支援的拓撲。
    • NUMBER_OF_CHIPS:容器要使用的 TPU 晶片數量。limits 和 requests 的值必須相同。
  2. 部署 ComputeClass:

    kubectl apply -f tpu-compute-class.yaml
    

    如要進一步瞭解自訂 ComputeClass 和 TPU,請參閱「TPU 設定」。

建立使用 TPU 的工作

  1. 將下列資訊清單儲存為 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: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
            ports:
            - containerPort: 8471 # Default port using which TPU VMs communicate
            - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
            command:
            - bash
            - -c
            - |
              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 必須使用相同的值,且等於所選自訂 ComputeClass 中的 CHIP_COUNT 值。
    • MEMORY_SIZE:TPU 使用的記憶體數量上限。記憶體限制取決於您使用的 TPU 版本和拓撲。詳情請參閱「加速器的數量下限和上限」。
    • NUMBER_OF_CHIPS:容器要使用的 TPU 晶片數量。limits 和 requests 的值必須相同。
  2. 部署工作:

    kubectl create -f tpu-job.yaml
    

    建立這項工作時,GKE 會自動執行下列操作:

    • 佈建節點來執行 Pod。視您指定的 TPU 類型、拓撲和資源要求而定,這些節點可能是單一主機配量或多主機配量。視最高優先順序的 TPU 資源可用性而定,GKE 可能會退而求其次,使用較低優先順序的資源,盡可能提高加速器容量的彈性、效率和可用性。
    • 在 Pod 新增 taint,並在節點新增容許規定,防止其他工作負載與 TPU 工作負載在相同節點上執行。

    詳情請參閱「關於自訂 ComputeClass」。

  3. 完成本節後,您可以刪除建立的資源,避免繼續計費:

    kubectl delete -f tpu-job.yaml
    

準備工作負載

TPU 工作負載必須符合下列準備需求。

  1. JAX、PyTorch 和 TensorFlow 等架構會使用 libtpu 共用程式庫存取 TPU VM。libtpu 包含 XLA 編譯器、TPU 執行階段軟體和 TPU 驅動程式。每個 PyTorch 和 JAX 版本都需要特定 libtpu.so 版本。為避免套件版本衝突,建議使用 JAX AI 圖像。如要在 GKE 中使用 TPU,請務必使用下列版本: tpu7x
    TPU 類型 「libtpu.so」版本
    Ironwood (TPU7x)
    TPU Trillium (v6e)
    tpu-v6e-slice
    TPU v5e
    tpu-v5-lite-podslice
    TPU v5p
    tpu-v5p-slice
    TPU v4
    tpu-v4-podslice
    TPU v3
    tpu-v3-slice
    tpu-v3-device
  2. 在工作負載資訊清單中,新增 Kubernetes 節點選取器,確保 GKE 根據您定義的 TPU 機型和 TPU 拓撲,排定 TPU 工作負載:

      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: TPU_ACCELERATOR
        cloud.google.com/gke-tpu-topology: TPU_TOPOLOGY
        cloud.google.com/placement-policy-name: WORKLOAD_POLICY # Required only for Ironwood (TPU7x)
      

    更改下列內容:

    • TPU_ACCELERATOR:TPU 加速器的名稱。例如,使用 tpu7x-standard-4t。
    • TPU_TOPOLOGY:TPU 配量的實體拓撲。拓撲格式取決於 TPU 版本。例如,使用 2x2x2。詳情請參閱「規劃 GKE 中的 TPU」。
    • WORKLOAD_POLICY:要用來放置 TPU Pod 的工作負載政策名稱。這個節點選取器僅適用於 Ironwood (TPU7x)。

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

以下各節將舉例說明如何執行工作,使用 TPU 執行基本運算。

在 TPU slice 節點上執行工作負載

本節說明如何準備工作負載,並提供執行工作負載的範例。

範例 1:執行在 Pod 規格中要求 TPU 的 Deployment

gcloud

GKE 會根據 Pod 或 ComputeClass 中的設定,決定 TPU 節點的設定。下列資訊清單是 Deployment 規格範例,會在 Pod 規格中要求 TPU。如果叢集層級的自動佈建節點設定已啟用,這項 Deployment 就會觸發節點集區自動建立功能。建立這個範例 Deployment 時,GKE 會建立節點集區,其中包含具有 2x2x2 拓撲和兩個 ct4p-hightpu-4t 機器的 TPU v4 切片。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tpu-workload
  labels:
    app: tpu-workload
spec:
  replicas: 2
  template:
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice
        cloud.google.com/gke-tpu-topology: 2x2x2
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        securityContext:
          privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("Total TPU chips:", jax.device_count())'
        resources:
          requests:
            google.com/tpu: 4
          limits:
            google.com/tpu: 4
        ports:
        - containerPort: 80

在這個資訊清單中,下列欄位定義了 TPU 設定:

  • cloud.google.com/gke-tpu-accelerator:TPU 版本和類型。例如,Ironwood (TPU7x) 請使用 tpu7x-standard-4t。
  • cloud.google.com/gke-tpu-topology:拓撲,包含 TPU 切片中的 TPU 晶片數量和實體排列方式。例如,使用 2x2x2。
  • limits.google.com/tpu:每個 VM 的 TPU 晶片數量。舉例來說,如果您使用 tpu7x-standard-4t,則每個 VM 的 TPU 晶片數量為 4。

Cluster Toolkit

使用 gcluster job submit 指令提交工作負載。如要進一步瞭解工作提交選項,請參閱「Cluster Toolkit 工作提交指南」:

gcluster job submit \
  --name=WORKLOAD_NAME \
  --cluster=DEPLOYMENT_NAME \
  --project=PROJECT_ID \
  --location=ZONE \
  --compute-type=COMPUTE_TYPE \
  --topology=TOPOLOGY \
  --num-slices=1 \
  --image=us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest \
  --command="python -c 'import jax; print(\"TPU cores:\", jax.device_count())'"

更改下列內容:

  • WORKLOAD_NAME:工作負載名稱。
  • DEPLOYMENT_NAME:Cluster Toolkit 部署作業的名稱 (也是 GKE 叢集的名稱)。
  • PROJECT_ID:您的 Google Cloud 專案 ID。
  • ZONE:根據您要使用的 TPU 版本,指定可用區名稱。如要找出可用的位置,請參閱「GKE 中的 TPU 可用性」。
  • COMPUTE_TYPE:與節點集區加速器類型相符的運算類型,例如 v6e-16、tpu7x-standard-4t 或 v5e-8。
  • TOPOLOGY:與節點集區相符的實體拓撲,例如 2x4 或 2x2x2。

範例 2:執行工作負載,顯示 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 # Node selector to target TPU v4 slice nodes.
            cloud.google.com/gke-tpu-topology: 2x2x4 # Specifies the physical topology for the TPU slice.
          containers:
          - name: tpu-job
            image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
            ports:
            - containerPort: 8471 # Default port using which TPU VMs communicate
            - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
            securityContext:
              privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
            command:
            - bash
            - -c
            - |
              python -c 'import jax; print("TPU cores:", jax.device_count())' # Python command to count available TPU chips.
            resources:
              requests:
                cpu: 10
                memory: 407Gi
                google.com/tpu: 4 # Request 4 TPU chips for this workload.
              limits:
                cpu: 10
                memory: 407Gi
                google.com/tpu: 4 # Limit to 4 TPU chips for this workload.
  2. 部署資訊清單:
    kubectl create -f available-chips-multihost.yaml
    

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

  3. 確認工作已建立四個 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
    

範例 3:執行工作負載,顯示 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 # Node selector to target TPU v5e slice nodes.
        cloud.google.com/gke-tpu-topology: 2x4 # Specify the physical topology for the TPU slice.
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        securityContext:
          privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("Total TPU chips:", jax.device_count())'
        resources:
          requests:
            google.com/tpu: 8 # Request 8 TPU chips for this container.
          limits:
            google.com/tpu: 8 # Limit to 8 TPU chips for this container.
  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
      

範例 4:執行指定兩個 NUMA 節點的工作負載

為提升工作負載效能,GKE 支援多容器設定,這會將每個容器繫結至特定 NUMA 節點中的 CPU、記憶體和 TPU 資源。如要進一步瞭解 NUMA 繫結,請參閱「關於 GKE 中的 Ironwood (TPU7x)」。

  1. 建立名為 topology-manager-config.yaml 的檔案,並在其中加入下列內容:

    kubeletConfig:
      cpuManagerPolicy: static
      topologyManager:
        policy: best-effort
        scope: container
    

    這項設定會將容器的資源要求,與單一 NUMA 節點對齊。GKE 必須採用這項設定,才能接受並正確指派晶片給多容器 TPU 工作負載。如需更多政策選項,請參閱「拓撲管理工具政策」。

  2. 建立新的節點集區或更新現有節點集區,將 kubelet 設定套用至節點集區。這個節點集區必須使用 Ironwood (TPU7x) 節點,例如 tpu7x-standard-4t 機器類型,以符合下一個步驟中的節點選取器。

    • 如要建立啟用 Topology Manager 的新節點集區,請按照下列步驟操作:

      gcloud container node-pools create NODE_POOL_NAME \
          --location=LOCATION \
          --cluster=CLUSTER_NAME \
          --node-locations=NODE_ZONES \
          --machine-type=tpu7x-standard-4t \
          --system-config-from-file=topology-manager-config.yaml
      

      更改下列內容:

      • NODE_POOL_NAME:新節點集區的名稱。
      • LOCATION:叢集區域。
      • CLUSTER_NAME:叢集名稱。
      • NODE_ZONES:以半形逗號分隔的清單,列出節點集區的一或多個可用區。
    • 如要更新已啟用拓撲管理工具的現有節點集區,請按照下列步驟操作:

      gcloud container node-pools update NODE_POOL_NAME \
          --location=LOCATION \
          --cluster=CLUSTER_NAME \
          --system-config-from-file=topology-manager-config.yaml
      

      更改下列內容:

      • NODE_POOL_NAME:節點集區的名稱。
      • LOCATION:叢集區域。
      • CLUSTER_NAME:叢集名稱。
  3. 建立名為 tpu-jobset.yaml 的檔案,並加入下列資訊清單:

    apiVersion: jobset.x-k8s.io/v1alpha2
    kind: JobSet
    metadata:
      name: tpu7x-test
    spec:
      failurePolicy:
        maxRestarts: 0
      replicatedJobs:
        - name: tpu7x
          replicas: 1
          template:
            spec:
              parallelism: 2
              completions: 2
              backoffLimit: 0
              template:
                spec:
                  subdomain: test
                  restartPolicy: Never
                  nodeSelector:
                    cloud.google.com/gke-tpu-accelerator: tpu7x
                    cloud.google.com/gke-tpu-topology: 2x2x2
                  containers:
                  - name: jax-tpu-1
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
                  - name: jax-tpu-2
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
    
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
    

    這個資訊清單定義了名為 tpu7x-test 的 JobSet,會執行 jax-tpu-1 和 jax-tpu-2 這兩個主要容器。每個容器會要求兩個 google.com/tpu 晶片。這兩個晶片來自同一個 NUMA 節點。接著,每個容器都會執行 Python 指令碼,驗證 JAX 是否能存取 TPU。

    這項 JobSet 設定顯示,同一個 Pod 中的多個容器可以存取及使用不同的 TPU 晶片。

  4. 套用資訊清單:

    kubectl apply -f tpu-jobset.yaml
    

範例 5:使用多 NIC Cloud Storage FUSE 磁碟區,執行多容器 TPU 工作負載

這個範例延伸自範例 4,加入使用 Cloud Storage FUSE 將 Cloud Storage FUSE bucket 掛接為磁碟區。這項設定會運用多 NIC 功能,可能提升網路效能。

  1. 建立名為 tpu7x-gcsfuse-multinic.yaml 的檔案,並加入下列資訊清單:

    apiVersion: jobset.x-k8s.io/v1alpha2
    kind: JobSet
    metadata:
      name: tpu7x-gcsfuse-multinic
    spec:
      failurePolicy:
        maxRestarts: 0
      replicatedJobs:
        - name: tpu7x
          replicas: 1
          template:
            spec:
              parallelism: 2
              completions: 2
              backoffLimit: 0
              template:
                spec:
                  subdomain: test
                  restartPolicy: Never
                  nodeSelector:
                    cloud.google.com/gke-tpu-accelerator: tpu7x
                    cloud.google.com/gke-tpu-topology: 2x2x2
                  hostNetwork: true
                  volumes:
                  - name: gcs0
                    csi:
                      driver: gcsfuse.csi.storage.gke.io
                      volumeAttributes:
                        bucketName: BUCKET_NAME
                        multiNICIndex: "0"
                        mountOptions: implicit-dirs
                        hostNetworkPodKSA: "true"
                  - name: gcs1
                    csi:
                      driver: gcsfuse.csi.storage.gke.io
                      volumeAttributes:
                        bucketName: BUCKET_NAME
                        multiNICIndex: "1"
                        mountOptions: implicit-dirs
                        hostNetworkPodKSA: "true"
                  containers:
                  - name: jax-tpu-1
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                      echo "Use /gcs${WORKLOAD_NIC_PREFERRED_NUMA}/ for Cloud Storage access"
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
                    volumeMounts:
                    - name: gcs0
                      mountPath: /gcs0
                      readOnly: false
                    - name: gcs1
                      mountPath: /gcs1
                      readOnly: false
                  - name: jax-tpu-2
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
    
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                      echo "Use /gcs${WORKLOAD_NIC_PREFERRED_NUMA}/ for Cloud Storage access"
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
                    volumeMounts:
                    - name: gcs0
                      mountPath: /gcs0
                      readOnly: false
                    - name: gcs1
                      mountPath: /gcs1
                      readOnly: false
    

    這個資訊清單會將下列 Cloud Storage FUSE 磁碟區掛接新增至範例 4。

    • 在磁碟區屬性中指定 multiNICIndex,即可為每個磁碟區使用對應 NUMA 節點上的網路介面。
    • 工作負載會使用 ${WORKLOAD_NIC_PREFERRED_NUMA} 環境變數選取 Cloud Storage FUSE 磁碟區,該磁碟區與指派給容器的 NUMA 節點相關聯。GKE 會將這個變數插入 Cloud TPU 工作負載的容器中。

    將 BUCKET_NAME 替換為 Cloud Storage bucket 名稱。

  2. 套用資訊清單:

    kubectl apply -f tpu7x-gcsfuse-multinic.yaml
    

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

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

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

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

清除所用資源

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

gcloud

刪除 TPU slice 節點集區:

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

更改下列內容:

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

Cluster Toolkit

刪除 Cluster Toolkit 部署作業:

  gcluster destroy DEPLOYMENT_NAME

將 DEPLOYMENT_NAME 替換為部署藍圖時建立的部署目錄名稱。

進行其他設定

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

使用多配量

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

遷移 TPU 預留項目

如果您已有 TPU 預留項目,必須先將 TPU 預留項目遷移至新的 Compute Engine 預留系統。您也可以建立以 Compute Engine 為基礎的預訂系統,無須遷移。如要瞭解如何遷移 TPU 預留項目,請參閱「TPU 預留項目」。

啟用記錄功能

GKE 記錄代理程式會收集 GKE 節點 (包括 TPU VM) 上執行的容器產生的記錄,並傳送至 Logging,您可以在 Logging 中查看。

設定 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 節點中,即將關機通知最多可設定為 5 分鐘。

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

防止排程死結

執行多個 TPU 工作或工作的多個副本時,不同工作的 Pod 可以在同一個 TPU 節點集區中排程。這可能會導致排程死結,使所有工作都無法取得足夠的節點來完成拓撲。

為降低排程死結的風險,請套用下列其中一項設定:

  • 使用 Pod 反相依性規則,確保不同工作的 Pod 不會排定在相同的 TPU 節點集區或拓撲網域。
  • 使用 jobset.sigs.k8s.io/exclusive-topology 註解,讓 JobSet 專門為自己的 Pod 宣告指定的拓撲網域 (例如節點集區)。

如需詳細的設定範例和疑難排解步驟,請參閱「排程死結」。

在不使用特殊權限模式的情況下執行容器

在 GKE 1.28 以上版本的節點中執行的容器,不需啟用特殊權限模式,即可存取 TPU。GKE 1.28 版及更早版本的節點需要特殊權限模式。

如果 TPU slice 節點執行的版本低於 1.28,請參閱下列章節:

在 TPU slice 的 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 Node Pool Status」(GKE TPU 節點集區狀態) 資訊主頁:

前往 GKE TPU 節點集區狀態

這個資訊主頁提供多主機 TPU 節點集區健康狀態的全面洞察資料。詳情請參閱「監控 TPU 節點和節點集區的健康指標」。

在 Google Cloud 控制台的「Kubernetes Clusters」頁面中,「Observability」(觀測能力) 分頁也會在「Accelerators」(加速器) >「TPU」標題下方,顯示 TPU 觀測能力 指標,例如 TPU 用量。 詳情請參閱「查看觀測能力指標」。

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

執行階段指標

在 GKE 1.27.4-gke.900 以上版本中,如果 TPU 工作負載使用 JAX 0.4.14 以上版本,並指定 containerPort: 8431,則會將 TPU 使用率指標匯出為 GKE 系統指標。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 節點和節點集區的健康指標

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

節點狀態

在 GKE 1.32.1-gke.1357001 以上版本中,下列 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}]))

節點集區狀態

k8s_node_pool 受監控資源的下列 GKE 系統指標會公開 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 查詢:

  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 查詢:

  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)

下列 GKE 系統指標會回報 GKE 多主機 TPU 節點集區在最近一次中斷結束到目前中斷開始之間的時間分布:

  • kubernetes.io/node_pool/accelerator/times_between_interruptions

這項指標記錄的每個樣本,都代表最近一次中斷與目前中斷之間的時間長度。

使用下列 PromQL 查詢,計算叢集過去 7 天內的中斷平均時間間隔 (MTBI):

sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_between_interruptions_sum{
    monitored_resource="k8s_node_pool", cluster_name="CLUSTER_NAME"}[7d]))
/
sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_between_interruptions_count{
    monitored_resource="k8s_node_pool",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 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 標籤。

  • 如要擴充收集作業,請手動調整節點集區大小,或透過節點自動佈建功能自動調整。

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

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

已知問題

  • 在新的 TPU 切片節點回報可用的 TPU 之前,叢集自動配置器可能會誤算這些節點的容量。叢集自動配置器可能會執行額外的擴充作業,導致建立的節點數量超過所需。在一般縮減作業後,叢集自動配置器會縮減不需要的其他節點。
  • 如果 TPU 切片節點集區處於等待狀態超過 10 小時,叢集自動配置器會取消擴充作業。叢集自動配置器稍後會重試這類擴充作業。這可能會降低未使用預留項目的客戶可用的 TPU 數量。
  • 如果非 TPU 工作負載容許 TPU 污點,且在 TPU 配量節點集區排空期間重新建立,就可能導致節點集區無法縮減。
  • v5e TPU 不支援記憶體頻寬使用率指標。

後續步驟