安装带有 VMware Tanzu 的 VMware vSphere#

在版本 1.1 中添加。

先决条件#

在部署带有 VMware Tanzu 的 VMware vSphere 之前，您必须确保您要部署到的虚拟基础架构满足先决条件。

注意

NVIDIA AI Enterprise 1.1 需要访问 NGC 上的 NVIDIA AI NGC 目录，并且需要对带有 Tanzu 的 vSphere 的管理员访问权限和管理网络。

重要提示

您至少需要配置两个单独的可路由子网，首选三个。一个子网用于管理网络（ESXi、vCenter、Supervisor 集群和负载均衡器）。第二个子网将用于工作负载网络（虚拟 IP 和 TKG 集群）以及前端网络（如果仅使用两个子网）。第三个子网用于前端网络。有关更多信息，请参阅vSphere with Tanzu 快速入门指南。

在继续本指南之前，必须安装和配置带有 Tanzu 的 vSphere。以下是安装步骤的概述。

  1. ESXi 安装在 3 台主机上。

    • ESXi 网络已配置，每台主机必须至少配置 2 个 NIC。

  2. VMware VCSA 已安装，并与 ESXi 主机位于同一网络上。配置如下

    • 集群已创建，并启用 HA 和 DRS。

    • 主机已添加到集群。

    • 共享存储或 vSAN 在数据存储中创建。

  3. VDS 已配置。

  4. 存储已配置。

  5. HAProxy（负载均衡器）已安装和配置。

  6. 启用工作负载管理。

  7. 命名空间已创建和配置。

  8. 所有 GPU 都配置为 vSphere 中的共享直通模式。

一旦带有 Tanzu 的 vSphere 成功安装和配置，则必须在 3 台 ESXi 主机中的每台主机上安装以下 NVIDIA AI Enterprise 软件。

注意

NVIDIA AI Enterprise 主机 (VIB) 和 Guest Driver Software 1.1 从 NGC 上的 NVIDIA AI NGC 目录中拉取。

一旦服务器配置了带有 Tanzu 的 vSphere 和 NVIDIA AI Enterprise。您将需要创建和部署 TKG 集群。本文档还假定 TKG 命名空间、TKG 集群内容库和 TKG 集群已创建并正在运行。

使用 NVIDIA vGPU 设备配置 Tanzu 集群#

当带有 Tanzu 的 vSphere 集群在数据中心运行时，企业内不同的角色执行各种任务。vSphere IT 管理员将通过创建与 NVIDIA vGPU 设备关联的必需组件来启动环境的初始配置。一旦初始配置完成，DevOps 工程师将设置 kubectl 并与之交互，并安装所需的 NV AI Enterprise 元素，例如 NVIDIA GPU 和 NVIDIA 网络运算符。下图说明了 vSphere IT 管理员和 DevOps 工程师执行的任务，绿色突出显示的是本指南中将介绍的步骤。

_images/vmware-tanzu-02.png

以下部分按角色讨论这些工作流程，以及详细配置带有 NVIDIA AI Enterprise 的 vSphere with Tanzu GPU 加速集群所需的步骤。

IT 管理员#

步骤 #1：创建 VM 类#

创建 GPU 加速类#

VM 类是对 VM 上用于处理能力（CPU 和 GPU）的资源预留的请求。例如，guaranteed-large 类具有 8 个 vCPU 和 NVIDIA T4 GPU。要调整 Tanzu Kubernetes 集群节点的大小，您可以指定虚拟机类。带有 Tanzu 的 vSphere 提供默认类，或者您可以创建自己的类。使用以下说明创建 GPU 加速 VM 类。

  1. 使用管理员访问权限登录 vCenter。

  2. 从 vCenter，导航到工作负载管理。

    _images/vmware-tanzu-03.png

  3. 在 VM 服务卡下选择服务和管理。

    _images/vmware-tanzu-04.png

  4. 选择 VM 类和创建 VM 类卡。

    _images/vmware-tanzu-05.png

  5. 输入 VM 类的名称，例如 vm-class-t4-16gb。

    _images/vmware-tanzu-06.png

    重要提示

    通过 Kubernetes CLI 与 VM 类交互的用户将无法轻松查看连接到关联节点的 GPU 类型，也无法查看可用的 GPU 内存。因此，应使用包含 GPU 类型和关联 GPU 内存的描述性名称。

    注意

    VM 类可以配置为使用 GPU 分区。GPU 分区可使用 NVIDIA AI Enterprise 软件分区或多实例 GPU (MIG)。以下步骤说明了如何使用 NVIDIA AI Enterprise 软件分区创建 VM 类。如果您想使用 MIG 创建 VM 类，请按照使用 MIG 创建 VM 类部分中的步骤操作。

  6. 选择下一步。

  7. 选择添加 PCI 设备下拉列表，然后选择 NVIDIA vGPU。

    _images/vmware-tanzu-07.png

  8. 从下拉列表中选择 GPU 型号。

    _images/vmware-tanzu-08.png

    注意

    连接到 Tanzu 集群的任何主机中的所有 GPU 都将可用。

  9. 使用 VM 类名称中指定的信息，填充所选 GPU 类型的可用选项

    • GPU 共享 – 时间共享

    • GPU 模式 – 计算

    _images/vmware-tanzu-09.png

    注意

    有两种类预留类型：保证和尽力而为。保证类完全预留其配置的资源。尽力而为类允许资源超额分配。在生产环境中，通常使用保证类类型。

  10. 单击下一步。

  11. 查看“查看并确认”页面上的信息，然后单击完成。

    _images/vmware-tanzu-10.png

您已使用带有 NVIDIA AI Enterprise 软件分区的 VM 类成功创建了 VM 类。

使用 MIG 创建 VM 类#

以下步骤说明了如何使用 MIG 创建 VM 类。并非所有 NVIDIA GPU 都支持 MIG，MIG 支持在部分 NVIDIA Ampere GPU（如 A100 或 A30）上可用。

注意

要使用 MIG 分区创建 VM 类，您首先需要配置 GPU 以使用 MIG。

  1. 输入 VM 类的名称，例如 vm-class-a30-24gb。

    _images/vmware-tanzu-11.png

  2. 选择下一步。

  3. 选择添加 PCI 设备下拉列表，然后选择 NVIDIA vGPU。

    _images/vmware-tanzu-12.png

  4. 从下拉列表中选择 GPU 型号。

    _images/vmware-tanzu-13.png

    注意

    连接到 Tanzu 集群的任何主机中的所有 GPU 都将可用。

  5. 添加 PCI 设备时，从 GPU 共享下拉列表中单击多实例 GPU 共享。

    _images/vmware-tanzu-14.png

  6. 使用 VM 类名称中指定的信息，填充所选 GPU 类型的可用选项。

    • GPU 共享 – 多实例 GPU 共享

    • GPU 模式 – 计算

    _images/vmware-tanzu-15.png

  7. 选择您要分配给 VM 的 GPU 分区切片的数量。

    注意

    GPU 内存下拉列表中列出的值特定于 NVIDIA GPU。例如，NVIDIA A30 具有以下配置。

    • 4 个 GPU 实例，每个 6GB

    • 2 个 GPU 实例，每个 12GB

    • 1 个 GPU 实例，24GB

    如果您输入的 GPU 内存值不等于有效的 GPU 配置文件，则生成的 VM 将使用下一个最小的配置文件。例如，如果您使用 A30 并选择 9GB，则生成的 VM 将具有 12GB 配置文件。

  8. 单击下一步。

  9. 查看“查看并确认”页面上的信息，然后单击“完成”。

    _images/vmware-tanzu-16.png

您已使用带有 NVIDIA MIG 分区的 VM 类成功创建了 VM 类。

使用 NVIDIA 网络创建 VM 类#

VM 类也可以与 NVIDIA 网络一起使用。NVIDIA 网卡可以作为 PCI 设备添加到 VM 类。您可以在不使用 GPU 的情况下将 VM 类与 NVIDIA 网络一起使用。在接下来的几个步骤中，我们将在已配置 NVIDIA vGPU 之后添加 NVIDIA Cx6 网卡。

注意

NVIDIA 网卡可以在 SR-IOV 模式下使用。这需要额外的设置，对于一般部署可能不需要。有关更多信息，请参阅操作指南：在 VMware ESXi 6.7/7.0 及更高版本上配置 SR-IOV 模式下的 NVIDIA ConnectX-5/6 适配器。

  1. 添加动态 DirectPath IO 设备。

    _images/vmware-tanzu-21.png

  2. 在“选择硬件”下拉列表中，选择可用的 ConnectC-6 DX 设备，或主机中可用的 NVIDIA 网卡。

    _images/vmware-tanzu-22.png

  3. 单击“下一步”并查看“确认”窗口。

  4. 单击“完成”。

    _images/vmware-tanzu-23.png

步骤 #2：将 VM 类与 Supervisor 的命名空间关联#

现在您已创建了 VM 类，我们将它与 Supervisor 命名空间关联。VM 类可以添加到 Supervisor 集群上的一个或多个命名空间，而 Supervisor 集群可以有一个或多个 VM 类。对于大多数部署，Supervisor 命名空间将具有多个 VM 类，以正确扩展 Kubernetes 集群。

注意

本文档假定 Supervisor 命名空间和内容库已创建并正在运行。出于演示目的，我们创建了一个名为 tkg-ns 的 Supervisor 命名空间。

  1. 从 vCenter，导航到工作负载管理。

  2. 展开您的 Tanzu 集群和关联的命名空间。

  3. 选择命名空间，然后在 VM 服务卡中单击“管理 VM 类”。

    _images/vmware-tanzu-17.png

  4. 从“管理 VM 类”弹出窗口中，选中您先前创建的 VM 类旁边的复选框。您可以选择一个或多个 VM 类，具体取决于您选择如何架构部署。

    VM 类 vm-class-t4-16gb（创建 GPU 加速类）在下面列出。

    _images/vmware-tanzu-18.png

    VM 类 vm-class-a30-24gb（使用 MIG 创建 VM 类）在下面列出。

    _images/vmware-tanzu-19.png

    VM 类 nvidia-a30-24c-cx6（使用 NVIDIA 网络创建 VM 类）在下面列出。

    _images/vmware-tanzu-24.png

  5. 单击确定。

  6. 验证内容库是否与 Supervisor 命名空间关联；在 VM 服务卡中单击添加内容库。

    _images/vmware-tanzu-20.png

  7. 从添加内容库弹出窗口中，选中订阅内容库的复选框，该库将包含 NVIDIA AI Enterprise 要使用的 VM 模板。

注意

NVIDIA AI Enterprise 使用的 VM 模板由 VMware 在订阅者内容库中提供。

重要提示

DevOps 工程师需要访问 VM 类，以便在新创建的命名空间中部署 Tanzu Kubernetes 集群。vSphere IT 管理员必须显式地将 VM 类与部署 Tanzu Kubernetes 集群的任何新命名空间关联。

DevOps 工程师#

步骤 #1：安装 Kubernetes CLI 工具#

DevOps 工程师将在 VM 上安装 Kubernetes CLI 工具，以与 Tanzu Kubernetes Grid 集群交互。这需要对 Tanzu 集群的网络访问。有关下载和安装 vSphere 的 Kubernetes CLI 工具的说明，请参见此处。

注意

TKG 集群和 VM 通过 Kubernetes CLI 工具创建和销毁。因此，AI 从业人员也可以与此工具交互。

下载并安装 Kubernetes CLI 工具后，执行以下步骤登录到主服务器并设置上下文。

注意

可以从您的环境通过浏览器访问 Kubernetes CLI 工具下载页面，方法是导航到 Supervisor 集群 VM 的 IP 地址。

  1. 通过在 Powershell 中运行以下命令，验证 vsphere*-plugin.zip 的 SHA256 校验和是否与提供的文件 sha256sum.txt 中的校验和匹配。

    Get-FileHash -Algorithm SHA256 -Path vsphere*-plugin.zip

    注意

    以上命令对 Kubernetes CLI 工具的 Microsoft Windows 版本有效。

  2. 在结果中验证确定。

  3. 将 .zip 文件的内容放在您操作系统的可执行搜索路径中。

  4. 运行以下命令登录到服务器。

    kubectl vsphere login --server=<IP_or_master_hostname>

  5. 运行以下命令查看您的命名空间列表。

    kubectl config get-contexts

  6. 运行以下命令选择您的默认上下文。

    kubectl config use-context <context>

  7. 使用命令查看集群的现有节点和 pod。

    1kubectl get nodes
2kubectl get pods -A

步骤 #2：创建 GPU 加速 TKG 集群#

我们将在本文档中创建一个 YAML 文件来创建 GPU 加速集群。此文件包含新的 TKG 集群名称、先前指定的 Supervisor 命名空间和 VM 类。

注意

建议在此集群的 containerd 存储上创建足够的空间，因为容器将存储在其中。

  1. 使用以下命令列出与该命名空间关联的所有 VMclass 实例。

    kubectl get virtualmachineclasses

  2. 使用以下命令查看特定类的 GPU 资源。

    kubectl describe virtualmachineclass <VMclass-name>

  3. 使用适合您的 VM 类的配置创建 YAML 文件。

    nano tanzucluster.yaml

  4. 使用以下信息填充 YAML 文件。

    警告

    以下 YAML 文件只能用于 vSphere 7.0 U3C

     1apiVersion: run.tanzu.vmware.com/v1alpha2
 2kind: TanzuKubernetesCluster
 3metadata:
 4name: tkg-a30-cx6
 5namespace: tkg-ns
 6spec:
 7topology:
 8  controlPlane:
 9        replicas: 3
10        vmClass: guaranteed-medium
11        storageClass: kubernetes-demo-storage
12  nodePools:
13  - name: nodepool-a30-cx6
14       replicas: 2
15       vmClass: nvidia-a30-24c-cx6
16       storageClass: kubernetes-demo-storage
17       volumes:
18       - name: containerd
19         mountPath: /var/lib/containerd
20         capacity:
21            storage: 100Gi
22
23
24  distribution:
25    fullVersion: 1.20.8+vmware.1-tkg.2
26  settings:
27    storage:
28      defaultClass: kubernetes-demo-storage
29  network:
30    cni:
31     name: antrea
32    services:
33     cidrBlocks: ["198.51.100.0/12"]
34    pods:
35    cidrBlocks: ["192.0.2.0/16"]
36    serviceDomain: local

    在版本 3.0 中添加。

    VSPHERE 8.0 的 YAML 示例

    VMware vSphere 8.0 需要更新的 TKR，该 TKR 使用 Ubuntu OS 作为集群节点。要为 NVIDIA AI Enterprise 3.0 创建集群，请利用此更新的示例 yaml 文件作为集群创建的起点。

     1 apiVersion: run.tanzu.vmware.com/v1alpha3
 2 kind: TanzuKubernetesCluster
 3 metadata:
 4 name: tme-emo
 5 namespace: tkg-ns
 6 annotations:
 7 run.tanzu.vmware.com/resolve-os-image: os-name=ubuntu
 8
 9
10 spec:
11 topology:
12     controlPlane:
13         replicas: 1
14         vmClass: guaranteed-medium
15         storageClass: kubernetes-demo-storage
16         tkr:
17             reference:
18             name: v1.23.8---vmware.2-tkg.2-zshippable
19     nodePools:
20     - name: nodepool-test
21         replicas: 2
22         vmClass: nvidia-a30-24c
23         storageClass: kubernetes-demo-storage
24         volumes:
25     - name: containerd
26         mountPath: /var/lib/containerd
27         capacity:
28         storage: 200Gi
29         tkr:
30         reference:
31         name: v1.23.8---vmware.2-tkg.2-zshippable
32
33
34 settings:
35 storage:
36     defaultClass: kubernetes-demo-storage
37 network:
38     cni:
39     name: antrea
40     services:
41     cidrBlocks: ["198.51.100.0/12"]
42     pods:
43     cidrBlocks: ["192.0.2.0/16"]
44     serviceDomain: managedcluster.local

    注意

    更多详细信息可以在此处找到：v1alpha3 示例：带有 Ubuntu TKR 的 TKC

    注意

    YAML 的“distribution - fullVersion”部分中给出的 OS 映像名称必须与您在 Supervisor 集群级别执行“kubectl get tkr”（tkr 是 Tanzu Kubernetes 版本）时看到的条目之一匹配。当您将内容库与命名空间关联时，该条目将放置在那里。

  5. 应用 YAML 以使用以下命令创建 TKG 集群。

    kubectl apply -f tanzucluster.yaml

  6. 执行以下命令以查看集群的状态。

    kubectl get tkc

  7. 等待直到集群准备就绪。

    _images/vmware-tanzu-25.png

  8. 当集群准备就绪时，IT 管理员将能够在 vCenter UI 中看到创建的集群。

    _images/vmware-tanzu-26.png

注意

如果您想 SSH 到 Tanzu 节点，请按照使用密码以系统用户身份 SSH 到 Tanzu Kubernetes 集群节点进行操作。

步骤 #3：安装 NVIDIA 运算符#

VMware 为 NVIDIA GPU 认证服务器上的 NVIDIA 虚拟 GPU 提供原生 TKG 支持，其中包含NVIDIA GPU 运算符和NVIDIA 网络运算符。这些 NVIDIA 运算符实现的节点加速基于运算符框架。我们将首先安装 NVIDIA 网络运算符，然后安装 NVIDIA GPU 运算符，以完全解锁 GPU Direct RDMA 功能。

要安装 NVIDIA 运算符，TKG 上下文必须设置为 TKG 集群命名空间（而不是 Supervisor 命名空间）。这可以通过运行以下命令来实现。

kubectl vsphere login --server=<Server-IP> --vsphere-username administrator@vsphere.local --insecure-skip-tls-verify --tanzu-kubernetes-cluster-name tkg-a30-cx6 --tanzu-kubernetes-cluster-namespace tkg-ns

注意

安装 NVIDIA 运算符以确保 MOFED 驱动程序就位至关重要。

部署 NVIDIA 网络运算符#

通过 Helm 的默认安装（如下所述）将部署 NVIDIA 网络运算符和相关的 CRD。还需要一个额外的步骤来创建 NicClusterPolicy 自定义资源，其中包含集群所需的配置。有关更多手动自定义资源创建信息，请参阅 NicClusterPolicy CRD 部分。

提供的 Helm 图表包含各种参数，以方便在部署时创建 NicClusterPolicy 自定义资源。有关图表参数的完整列表，请参阅NVIDIA 网络运算符 Helm 图表 README。

每个 NVIDIA 运算符版本都有一组它部署的各种组件的默认版本值。建议不要更改这些值。测试和验证是使用这些值执行的，当使用不同的版本时，既不能保证互操作性，也不能保证正确性。

  1. 获取 NVIDIA 网络运算符 Helm 图表。

    helm fetch https://helm.ngc.nvidia.com/nvaie/charts/network-operator-v1.1.0.tgz --username='$oauthtoken' --password=<YOUR API KEY> --untar

  2. 创建具有适当配置的 YAML 文件。

    nano values.yaml

  3. 使用以下信息填充 YAML 文件。

    1 deployCR: true
2 ofedDriver:
3  deploy: true
4 rdmaSharedDevicePlugin:
5  deploy: true
6  resources:
7   - name: rdma_shared_device_a
8   vendors: [15b3]
9   devices: [ens192]

  4. 使用以下命令安装 NVIDIA 网络运算符。

    helm install network-operator -f ./values.yaml -n network-operator --create-namespace --wait network-operator/

部署 NVIDIA GPU 运算符#

  1. 创建 NVIDIA GPU 运算符命名空间。

    kubectl create namespace gpu-operator

  2. 将 CLS 许可证令牌复制到名为 client_configuration_token.tok 的文件中。

  3. 创建一个空的 gridd.conf 文件。

    touch gridd.conf

  4. 为 CLS 许可创建 Configmap。

    kubectl create configmap licensing-config -n gpu-operator --from-file=./gridd.conf --from-file=./client_configuration_token.tok

  5. 创建 K8s Secret 以访问 NGC 注册表。

    kubectl create secret docker-registry ngc-secret --docker-server="nvcr.io/nvaie" --docker-username='$oauthtoken' --docker-password=’<YOUR API KEY>’ --docker-email=’<YOUR EMAIL>’ -n gpu-operator

  6. 覆盖标签安全性

    kubectl label --overwrite ns gpu-operator pod-security.kubernetes.io/warn=privileged  pod-security.kubernetes.io/enforce=privileged

  7. 添加 Helm Repo。

    helm repo add nvaie https://helm.ngc.nvidia.com/nvaie --username='$oauthtoken' --password=<YOUR API KEY>

  8. 更新 Helm Repo。

    helm repo update

  9. 安装 NVIDIA GPU 运算符。

    helm install --wait gpu-operator nvaie/gpu-operator -n gpu-operator

验证 NVIDIA GPU 运算符部署#

  1. 使用以下命令找到 NVIDIA 驱动程序守护程序集。

    kubectl get pods -n gpu-operator

  2. 找到标题以 nvidia-driver-daemonset-xxxxx 开头的 pod。

  3. 使用上面找到的 pod 运行 nvidia-smi。

     1sysadmin@sn-vm:~$ kubectl exec -ti -n gpu-operator nvidia-driver-daemonset-sdtvt -- nvidia-smi
 2Defaulted container "nvidia-driver-ctr" out of: nvidia-driver-ctr, k8s-driver-manager (init)
 3Thu Jan 27 00:53:35 2022
 4+-----------------------------------------------------------------------------+
 5| NVIDIA-SMI 470.103.01   Driver Version: 470.103.01   CUDA Version: 11.4     |
 6|-------------------------------+----------------------+----------------------+
 7| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
 8| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
 9|                               |                      |               MIG M. |
10|===============================+======================+======================|
11|   0  GRID T4-16C         On   | 00000000:02:00.0 Off |                    0 |
12| N/A   N/A    P8    N/A /  N/A |   2220MiB / 16384MiB |      0%      Default |
13|                               |                      |                  N/A |
14+-------------------------------+----------------------+----------------------+
15
16
17+-----------------------------------------------------------------------------+
18| Processes:                                                                  |
19|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
20|        ID   ID                                                   Usage      |
21|=============================================================================|
22|  No running processes found                                                 |
23+-----------------------------------------------------------------------------+

安装带有 VMware Tanzu 的 VMware vSphere（气隙环境）#

在版本 1.1 中添加。

先决条件#

注意

许可证服务器 - 为了使 Tanzu 主机和相关 VM 连接 GPU 设备，需要委派许可证服务器 (DLS) 为断开连接的网络上的客户端提供许可证

有关 DLS 的安装和配置的详细信息，请参阅许可证系统用户指南。

  1. 堡垒主机 - 本指南在 vSphere 集群上部署 Linux VM，以通过专用网络与 Tanzu 交互，并托管 kubectl、helm 和 docker 等工具

    • 操作系统：Ubuntu 22.04 或 20.04（推荐）

    • 建议使用 20.04，以避免需要镜像两个版本的软件存储库

    • 存储：最小 25G

    • CPU：2

    • 内存：4

  2. 镜像主机 - 如果策略允许，可以与堡垒主机相同

    • 操作系统：Ubuntu 22.04 或 20.04（推荐）

    • 存储：最小 400G

    • CPU：2

    • 内存：4

    • 端口：80

  3. 本地容器注册表 - 本指南使用 Harbor OVA

    • 存储：最小 100G

    • CPU：2

    • 内存：4

    • 端口：5000

    在继续本指南之前，必须安装和配置带有 Tanzu 的 vSphere。请参阅创建本地 TKR 内容库，作为在离线环境中部署 VMware Tanzu 的先决条件。

  4. ESXi 安装在 3 台主机上。

    • ESXi 网络已配置，每台主机必须至少配置 2 个 NIC。

  5. VMware VCSA 已安装，并与 ESXi 主机位于同一网络上。配置如下

    • 集群已创建，并启用 HA 和 DRS。

    • 主机已添加到集群。

    • 共享存储或 vSAN 在数据存储中创建。

  6. VDS 已配置。

  7. 存储已配置。

  8. HAProxy（负载均衡器）已安装和配置。

  9. 启用工作负载管理。

  10. 命名空间已创建和配置。

  11. 所有 GPU 都配置为 vSphere 中的共享直通模式。

一旦带有 Tanzu 的 vSphere 成功安装和配置，则必须在 3 台 ESXi 主机中的每台主机上安装以下 NVIDIA AI Enterprise 软件。

注意

NVIDIA AI Enterprise 主机 (VIB) 和 Guest Driver Software 1.1 从 NGC 上的 NVIDIA AI NGC 目录中拉取。

一旦服务器配置了带有 Tanzu 的 vSphere 和 NVIDIA AI Enterprise。您将需要创建和部署 TKG 集群。本文档还假定 TKG 命名空间、TKG 集群内容库和 TKG 集群已创建并正在运行。

气隙部署入门#

本页介绍如何在互联网访问受限的集群中部署 GPU 运算符。默认情况下，GPU 运算符需要互联网访问，用于

  • 在 GPU 运算符安装期间需要拉取容器映像

  • 驱动程序容器需要在驱动程序安装之前下载多个操作系统软件包

为了满足这些要求，可能需要创建本地映像注册表和/或本地软件包存储库，以便必要的映像和软件包可用于您的集群。在后续部分中，我们将详细介绍如何配置 GPU 运算符以使用本地映像注册表和本地软件包存储库。Helm 图表定义可以作为捆绑包下载，并在具有 Tanzu 集群访问权限的主机上本地使用。Helm 图表仅包含部署的定义，因此映像必须托管在 Tanzu Kubernetes 集群可访问的容器注册表中。目前，Tanzu Kubernetes 集群可以使用私有的 docker 兼容容器注册表，例如 Harbor、Docker 或 Artifactory。有关更多信息，请参阅VMware Tanzu Kubernetes Grid 气隙参考设计。

_images/vmware-tanzu-29.png

部署堡垒主机#

堡垒主机或跳转主机是位于同一专用网络上并具有外部连接的主机。它在本指南中的目的是保存来自外部来源的内容，例如 Helm 客户端、kubectl 和 Ubuntu 镜像，并使它们可用于专用网络上的系统。这通过将通信限制到已知主机来减少专用网络的整体攻击面。堡垒主机可能能够直接从互联网下载软件到本地存储，并将其重新分发到专用网络上的主机。如果它没有互联网访问权限，则需要在单独的主机上下载软件，并使用另一种方法上传到堡垒主机。

下图是一个受限互联网场景的示例，其中堡垒主机具有互联网连接。

_images/vmware-tanzu-28.png

下图是一个气隙场景的示例，其中软件必须存储在可移动存储设备上并上传到堡垒主机。

_images/vmware-tanzu-27.png

设置本地软件包存储库#

支持此安装方法需要多个软件包。例如，作为 GPU 运算符一部分部署的驱动程序容器需要某些软件包作为驱动程序安装的一部分可用。在互联网访问受限或气隙安装中，用户需要为其操作系统发行版创建本地镜像存储库。例如，需要以下软件包

linux-headers-${KERNEL_VERSION}

linux-image-${KERNEL_VERSION}

linux-modules-${KERNEL_VERSION}

注意

KERNEL_VERSION 是 GPU 节点上运行的基础内核版本。

本指南将在堡垒主机上部署软件包存储库，以便网络上的计算机可以从那里获取软件包。

如果堡垒主机具有互联网连接（直接连接或通过代理），则可以使用 apt-mirror 在堡垒主机上直接创建镜像存储库，并通过 nginx 等 Web 服务器通过专用网络提供服务。ls

如果堡垒主机没有互联网连接，仍然可以使用 apt-mirror，但镜像内容需要使用其他方法复制到堡垒主机。可能的方法是通过专用网络连接或可移动介质（如 USB 存储）。

要使用 apt-mirror 创建 Ubuntu 20.04 的镜像，请在可以访问 archive.ubuntu.com 的 Ubuntu 主机上运行以下步骤，以创建镜像，并在 /var/spool/mirror 上挂载足够的存储空间以满足先决条件中描述的要求。

 1### on the internet-connected host ###
 2$ apt install apt-mirror
 3#configure mirror.list
 4vim /etc/apt/mirror.list
 5############# config ##################
 6#
 7# set base_path    /var/spool/apt-mirror
 8#
 9# set mirror_path  $base_path/mirror
10# set skel_path    $base_path/skel
11# set var_path     $base_path/var
12# set cleanscript $var_path/clean.sh
13# set defaultarch  <running host architecture>
14# set postmirror_script $var_path/postmirror.sh
15# set run_postmirror 0
16set nthreads     20
17set _tilde 0
18#
19############# end config ##############
20clean http://archive.ubuntu.com/ubuntu
21deb http://archive.ubuntu.com/ubuntu focal-security main restricted universe multiverse
22deb http://archive.ubuntu.com/ubuntu focal-updates main restricted universe multiverse
23deb http://archive.ubuntu.com/ubuntu focal-proposed main restricted universe multiverse
24deb http://archive.ubuntu.com/ubuntu focal-backports main restricted universe multiverse
25
26
27
28
29$ /usr/bin/apt-mirror

如果需要将镜像上传到断开连接的堡垒主机，请将配置的 base_path（默认为 /var/spool/apt-mirror）的结果内容复制到堡垒主机上的同一路径，然后再继续执行配置 Web 服务器的下一步。

Web 服务器设置#

本指南将在堡垒主机上部署 nginx，以提供使用 GPU 运算符 v23.6.1 所需的 Ubuntu 20.04 镜像。

注意

检查您的 GPU 运算符版本使用的容器映像的操作系统版本。您可能需要镜像 22.04 和 20.04 才能支持多个版本的 GPU 运算符。您可以通过检查 NGC 中的标签来找到容器映像的基础操作系统版本。更多详细信息可以在本指南稍后描述的“设置本地容器注册表”中找到。

对于具有互联网连接的堡垒主机，可以从公共互联网上的默认源安装 nginx。

安装 nginx

1apt-get update
2apt-get install nginx

对于没有互联网连接的堡垒主机，主机可以通过更新 sources.list 文件以指向本地目录，从先前部分中创建的本地软件包镜像安装 nginx 软件包。

配置 apt 以使用本地镜像

1vim /etc/apt/sources.list
2###### Ubuntu Main Repos
3deb file:///var/spool/apt-mirror/mirror/archive.ubuntu.com/ubuntu/
4/ubuntu/ focal main restricted universe multiverse

 1systemctl enable nginx
 2systemctl start nginx
 3vim /etc/nginx/conf.d/mirrors.conf
 4server {
 5listen 80;
 6server_name <mirror.domain.com>;
 7root /var/spool/apt-mirror/mirror/archive.ubuntu.com/;
 8
 9
10location / {
11autoindex on;
12  }
13}
14$ systemctl restart nginx

需要在每个客户端上打开防火墙端口 TCP/80，以便从该镜像获取软件包。

验证软件包是否可从配置为使用镜像存储库的 /etc/apt/sources.list 的主机获得。

1apt-get update
2apt-cache search linux-headers linux-image linux-modules

在堡垒主机上安装其他必需的软件。请参阅每个软件包的安装方法。如果堡垒主机缺少互联网连接，所有这些软件包都支持气隙安装方法。

设置本地容器映像注册表#

在没有互联网访问的情况下，GPU 运算符需要所有映像都托管在集群中所有节点都可以访问的本地映像注册表中。为了使 GPU 运算符能够与本地注册表一起工作，用户可以在 values.yaml 中指定本地存储库、映像和标签以及拉取密钥。

要从 NVIDIA 注册表中拉取特定映像，您可以利用 values.yaml 中的 repository、image 和 version 字段。容器映像的通用语法是 <repository>/<image>:<version>。

如果未指定版本，您可以从 NVIDIA NGC 目录 https://catalog.ngc.nvidia.com/containers/ 中检索信息。搜索映像，例如 gpu-operator，然后检查映像的可用标签。

对于 NVIDIA AI Enterprise 包含的映像（如 GPU 运算符），需要通过 API 密钥进行身份验证。请参阅有关生成 API 密钥的 NGC 文档。如果 API 密钥已存在，则可以重复使用。

拉取容器映像#

NGC 目录中存储的容器映像需要身份验证。使用保留用户名 $oauthtoken 登录 docker，并将 API 密钥粘贴到密码字段中。NGC 将识别字符串 $oauthtoken 为 API 登录名，密码字符在终端上不可见。

1docker login nvcr.io
2Username: $oauthtoken
3Password:
4WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
5Configure a credential helper to remove this warning. See
6http://docs.docker.net.cn/engine/reference/commandline/login/#credentials-store
7Login Succeeded

要拉取 gpu-operator-4-0 映像版本 v23.6.1，请使用以下命令

docker pull nvcr.io/nvaie/gpu-operator-4-0:v23.6.1

某些映像是为特定操作系统构建的。对于这些映像，版本字段必须附加在工作节点上运行的操作系统名称。

例如，拉取 Ubuntu 20.04 的驱动程序映像

docker pull nvcr.io/nvidia/driver:535.104.05-ubuntu20.04

要拉取 GPU 运算符 23.6.1 的其余映像，以下命令将拉取每个映像的正确版本。

注意

映像列表在本节末尾提供

 1docker pull nvcr.io/nvidia/kubevirt-gpu-device-plugin:v1.2.2
 2docker pull nvcr.io/nvidia/cloud-native/k8s-cc-manager:v0.1.0
 3docker pull nvcr.io/nvidia/cloud-native/k8s-kata-manager:v0.1.1
 4docker pull nvcr.io/nvidia/cloud-native/k8s-driver-manager:v0.6.2
 5docker pull nvcr.io/nvidia/cuda:12.2.0-base-ubi8
 6docker pull nvcr.io/nvidia/k8s/container-toolkit:v1.13.4-ubuntu20.04
 7docker pull nvcr.io/nvidia/cloud-native/gpu-operator-validator:v23.6.1
 8docker pull nvcr.io/nvidia/cloud-native/vgpu-device-manager:v0.2.3
 9docker pull nvcr.io/nvidia/k8s/dcgm-exporter:3.1.8-3.1.5-ubuntu20.04
10docker pull nvcr.io/nvidia/cloud-native/dcgm:3.1.8-3.1.5-ubuntu20.04
11docker pull nvcr.io/nvidia/k8s-device-plugin:v0.14.1
12docker pull nvcr.io/nvidia/k8s/container-toolkit:v1.14.1-ubuntu20.04
13docker pull nvcr.io/nvidia/gpu-feature-discovery:v0.8.1
14docker pull nvcr.io/nvaie/gpu-operator-4-0:v23.6.1
15docker pull nvcr.io/nvaie/vgpu-guest-driver-4-0:535.104.05-ubuntu20.04
16docker pull registry.k8s.io/nfd/node-feature-discovery:v0.13.1

注意

如果使用不同版本的 GPU 运算符，则确切的标签可能不同。

如果使用与 23.6.1 不同的版本。从 GPU 运算符 Helm 图表中包含的 values.yaml 文件中定义的映像获取确切的标签。

1helm fetch https://helm.ngc.nvidia.com/nvaie/charts/gpu-operator-<version> --username='$oauthtoken' --password=<YOUR API KEY>
2tar xvf gpu-operator-<version>
3cd gpu-operator-<version>
4cat values.yaml

为方便起见，以下是 GPU 运算符使用的映像的易于复制的列表

 1nvcr.io/nvidia/kubevirt-gpu-device-plugin:v1.2.2
 2nvcr.io/nvidia/cloud-native/k8s-cc-manager:v0.1.0
 3nvcr.io/nvidia/cloud-native/k8s-kata-manager:v0.1.1
 4nvcr.io/nvidia/cloud-native/k8s-driver-manager:v0.6.2
 5nvcr.io/nvidia/cuda:12.2.0-base-ubi8
 6nvcr.io/nvidia/k8s/container-toolkit:v1.13.4-ubuntu20.04
 7nvcr.io/nvidia/cloud-native/gpu-operator-validator:v23.6.1
 8nvcr.io/nvidia/cloud-native/vgpu-device-manager:v0.2.3
 9nvcr.io/nvidia/k8s/dcgm-exporter:3.1.8-3.1.5-ubuntu20.04
10nvcr.io/nvidia/cloud-native/dcgm:3.1.8-3.1.5-ubuntu20.04
11nvcr.io/nvidia/k8s-device-plugin:v0.14.1
12nvcr.io/nvidia/k8s/container-toolkit:v1.14.1-ubuntu20.04
13nvcr.io/nvidia/gpu-feature-discovery:v0.8.1
14nvcr.io/nvaie/gpu-operator-4-0:v23.6.1
15nvcr.io/nvaie/vgpu-guest-driver-4-0:535.104.05-ubuntu20.04
16registry.k8s.io/nfd/node-feature-discovery:v0.13.1

准备私有注册表#

来自 NGC 的容器映像可以推送到任何符合 OCI 标准的注册表，例如docker 注册表、Harbor 或 Artifactory。本指南将包括 Harbor 的步骤。

要部署 Harbor，请参阅官方文档。

创建以下项目并将其公开：nvaie、nvidia 和 nfd

_images/vmware-tanzu-30.png

单击项目以下载注册表证书并将其保存到堡垒主机上的 /usr/local/share/ca-certificates/ca.crt。

1user@bastion:~$ ls /usr/local/share/ca-certificates/ca.crt
2ca.crt

更新堡垒主机上的本地信任存储，以便 docker 可以与 Harbor 交互

1sudo update-ca-certificates
2systemctl restart docker

注意

docker 客户端在拉取和推送注册表时默认使用 HTTPS，如果使用不安全的注册表，则会失败。有关处理不安全注册表的信息，请参阅docker 文档。

重新标记映像以指向本地私有注册表#

对于 GPU 运算符所需的每个映像，运行以下命令以创建新标记的映像

1docker tag nvcr.io/nvidia/gpu-operator:v23.6.1
2<harbor.yourdomain.com>/<local-path>/gpu-operator:v23.6.1
3docker tag nvcr.io/nvidia/driver:535.104.05-ubuntu20.04 <harbor.yourdomain.com>/<local-path>/driver:535.104.05-ubuntu20.04
4...

保存镜像以供离线上传#

如果您的容器 registry 无法从用于从 NGC 拉取镜像的主机访问，则需要将镜像导出为 tar.gz 文件，并复制到已安装 docker 客户端的专用网络中的主机上。

镜像保存示例

docker save <harbor.yourdomain.com>/nvidia/kubevirt-gpu-device-plugin:v1.2.2 -o kubevirt-gpu-device-plugin-1.2.2.tar.gz

镜像加载示例

docker load --input kubevirt-gpu-device-plugin-1.2.2.tar.gz

验证已加载的镜像

docker images

将新标记的镜像推送到 Harbor#

对于 GPU Operator 所需的每个镜像，运行以下命令以推送到本地 registry

1docker login harbor.yourdomain.com
2docker push <harbor.yourdomain.com>/<local-path>/gpu-operator:v23.3.2
3docker push <harbor.yourdomain.com>/<local-path>/driver:470.82.01-ubuntu20.04

从堡垒机访问 Tanzu#

在 vSphere 集群中配置 Tanzu 的内容，请参阅 Tanzu 与 NVIDIA AI Enterprise 的部署指南 和 使用 NVIDIA vGPU 设备和 NVIDIA AI Enterprise 配置 Tanzu 集群。 请注意确保用于在 ESXi 主机上安装主机驱动程序的 VIB 与 GPU Operator 部署的 NVIDIA 驱动程序版本相匹配。

注意

通过直接从主机的 shell 运行 nvidia-smi 命令，检查安装在 ESXi 主机上的 VIB 版本

登录到目标 Tanzu Kubernetes 集群#

在堡垒机上，确保已安装 vSphere 的 Kubernetes CLI 工具以及 kubectl 的 vSphere 插件。 有关安装这些工具的信息，请参阅官方文档。 登录到连接了 vGPU 设备的 Tanzu 集群（而不是 Supervisor 集群）。

1kubectl vsphere login --server=<Server-IP> --vsphere-username administrator@vsphere.local --insecure-skip-tls-verify --tanzu-kubernetes-cluster-name <cluster-name> --tanzu-kubernetes-cluster-namespace <cluster-namespace>
2KUBECTL_VSPHERE_PASSWORD environment variable is not set. Please enter the password below
3Password:
4Logged in successfully.
5You have access to the following contexts:
6<redacted>
7If the context you wish to use is not in this list, you may need to try
8logging in again later, or contact your cluster administrator.
9To change context, use `kubectl config use-context <workload name>`

将 Harbor 证书添加到集群#

Kubernetes 使用本地主机的信任存储来保护通信。 如果 Harbor 证书未包含在信任存储中，则镜像将无法拉取。

通过更新 Supervisor 集群上的 TkgsServiceConfiguration，将 Harbor 的 CA 证书添加到 Tanzu 主机。 证书文件必须转换为 base64 才能添加到集群。

 1kubectl config set-context SUPERVISOR_CLUSTER_NAME
 2base64 -i /usr/local/shar/ca-certificates/ca.crt
 3<output>
 4vim tkgs-cert.yaml
 5apiVersion: run.tanzu.vmware.com/v1alpha1
 6kind: TkgServiceConfiguration
 7metadata:
 8name: tkg-service-configuration
 9spec:
10defaultCNI: antrea
11trust:
12    additionalTrustedCAs:
13    - name: harbor-ca-cert
14        data: <output>
15kubectl apply -f tkgs-cert.yaml

理想情况下，此配置在配置工作负载集群之前完成。 如果集群已配置，您可以传播证书或任何其他全局设置，通过补丁的方式。

为 GPU Operator 创建 ConfigMap#

GPU Operator 默认配置为使用互联网资源。 在部署之前，需要创建配置映射以指向我们的私有资源。 这些 ConfigMap 是 Kubernetes 对象，由 GPU Operator 部署的 Pod 挂载。

首先，登录到目标 Tanzu Kubernetes 集群

kubectl vsphere login --server=<Server-IP> --vsphere-username administrator@vsphere.local --insecure-skip-tls-verify --tanzu-kubernetes-cluster-name <cluster-name> --tanzu-kubernetes-cluster-namespace <tanzu-namespace>

创建 GPU Operator 命名空间

kubectl create namespace gpu-operator

本地软件包仓库配置#

创建一个指向我们本地软件包仓库的 custom-repo.list 文件

1vim custom-repo.list
2deb [arch=amd64] http://<local pkg repository>/ubuntu/ focal main universe
3deb [arch=amd64] http://<local pkg repository>/ubuntu/ focal-updates main universe
4deb [arch=amd64] http://<local pkg repository>/ubuntu/focal-security main universe

在 gpu-operator 命名空间中使用 custom-repo.list 中给出的自定义仓库信息，创建一个名为 repo-config 的 ConfigMap 对象

kubectl create configmap repo-config -n gpu-operator --from-file=./custom-repo.list

NVIDIA AI Enterprise 许可证配置#

创建一个空的 gridd.conf 文件

touch gridd.conf

创建许可证令牌。 有关创建许可证令牌的信息，请参阅 NVIDIA 许可证系统用户指南。

为许可证创建 Configmap

kubectl create configmap licensing-config -n gpu-operator --from-file=./gridd.conf --from-file=./client_configuration_token.tok

私有仓库身份验证#

如果在 Harbor 中创建的项目标记为私有，则需要身份验证。 如果项目是公共的，则可以跳过此步骤。

创建一个 Kubernetes Secret，用于对本地 registry 进行身份验证。 Helm chart 默认使用名称 “ngc-secret”。 为了避免对 Helm chart 进行额外的更改，请重复使用此名称。 Secret 是从 docker 客户端的缓存凭据创建的。 在创建 Secret 之前，使用 docker 客户端登录 Harbor 以验证凭据。

1docker login <harbor.my.domain>
2kubectl create secret generic ngc-secret --from-file=.dockerconfigjson=~/.docker/config.json --type=kubernetes.io/dockerconfigjson -n gpu-operator

更新 GPU Operator Helm Chart 定义#

Helm Charts 默认配置为使用公共资源。 在气隙环境中安装 GPU Operator 之前，需要为气隙环境更新 values.yaml 文件。

从可以访问 NGC 的主机复制 Helm chart。 此命令会将 Helm chart 下载为压缩的 tar 文件。 它可以解压缩并在本地使用，无需互联网连接。

  • 请参阅安装 Helm 客户端二进制文件的先决条件

  • 如果您需要创建 API 密钥，请参阅 NGC 用户指南

1helm fetch https://helm.ngc.nvidia.com/nvaie/charts/gpu-operator-4-0-v23.6.1.tgz --username='$oauthtoken' --password=<YOUR API KEY>
2tar xvf gpu-operator-4-0-v23.6.1.tgz
3cd gpu-operator-4-0

将 ConfigMap 添加到 Helm Chart#

使用以下信息更新 values.yaml，使 GPU Operator 在驱动程序容器中挂载私有软件包仓库配置，以拉取所需的软件包。 根据操作系统发行版，GPU Operator 会自动将此 ConfigMap 挂载到相应的目录中。

1vim values.yaml
2driver:
3repoConfig:
4    configMapName: repo-config

如果基于 HTTPS 的内部仓库使用自签名证书，则必须为这些证书添加一个 ConfigMap。 然后在 GPU Operator 安装期间指定 ConfigMap。 根据操作系统发行版，GPU Operator 会自动将此 ConfigMap 挂载到相应的目录中。 同样，证书文件格式和后缀（例如 .crt 或 .pem）也取决于操作系统发行版。

1kubectl create configmap cert-config -n gpu-operator --from-file=<path-to-cert-file-1> --from-file=<path-to-cert-file-2>

更新镜像规范以使用本地 Registry#

对于 values.yaml 中的每个镜像，更改名称以指向私有 registry。 例如，将 kubevirt-gpu-device-plugin 从 nvcr.io 更改为您为 <harbor.mydomain.com> registry 设置的值

1sandboxDevicePlugin:
2    sandboxDevicePlugin:
3    enabled: true
4    repository: <harbor.mydomain.com>/nvidia
5    image: kubevirt-gpu-device-plugin
6    version: v1.2.2

Node Feature Discovery 负责为具有 GPU 设备的节点添加节点标签。 GPU Operator 默认部署社区维护的子图表。 要覆盖子图表的默认镜像，请将此节添加到 node-feature-discovery 部分，该部分指向私有 registry。

1node-feature-discovery:
2image:
3    repository:<harbor.mydomain.com>/nfd/node-feature-discovery

安装 GPU Operator#

通过 Helm chart 安装 NVIDIA GPU Operator

helm install --wait gpu-operator ./gpu-operator -n gpu-operator

监控进度。

watch kubectl get pods -n gpu-operator
本页内容