33 GPU NVIDIA en SUSE Linux Micro #

Esta guía muestra cómo implementar compatibilidad con GPU NVIDIA a nivel de host mediante controladores de código abierto creados previamente en SUSE Linux Micro 6.1. Estos controladores están integrados en el sistema operativo, en lugar de cargarse de forma dinámica mediante el operador GPU Operator de NVIDIA. Esta configuración es muy recomendable para los clientes que desean integrar previamente todos los artefactos necesarios para el despliegue en la imagen y en cuando sea necesario seleccionar dinámicamente la versión del controlador; es decir, que el usuario pueda seleccionar la versión del controlador a través de Kubernetes. Al principio de esta guía se explica cómo desplegar los componentes adicionales en un sistema que ya ha sido desplegado previamente, y continúa con una sección donde se describe cómo integrar esta configuración en el despliegue inicial mediante Edge Image Builder. Si no desea repasar los conceptos básicos y configurarlo todo manualmente, pase directamente a esa sección.

Es importante destacar que la asistencia para estos controladores la proporcionan tanto SUSE como NVIDIA en estrecha colaboración, y que el controlador ha sido creado y lo proporciona SUSE como parte de los repositorios de paquetes. Sin embargo, si tiene alguna duda o pregunta sobre la combinación en la que utiliza los controladores, solicite ayuda adicional a sus gestores de cuentas de SUSE o NVIDIA. Si tiene previsto utilizar NVIDIA AI Enterprise (NVAIE), asegúrese de que está utilizando una GPU certificada para NVAIE, lo que puede requerir el uso de controladores de NVIDIA. Si no está seguro, consulte con su representante de NVIDIA.

Esta guía no incluye más información sobre la integración del operador GPU de NVIDIA. Aunque no trata sobre la integración del operador de GPU de NVIDIA para Kubernetes, puede seguir la mayoría de los pasos de esta guía para configurar el sistema operativo subyacente y, simplemente, habilitar el operador de GPU para que utilice los controladores preinstalados mediante el indicador driver.enabled=false en el chart de Helm del operador de GPU NVIDIA, donde bastará con seleccionar los controladores instalados en el host. Encontrará instrucciones más completas de NVIDIA en este documento.

Si está siguiendo esta guía, se da por hecho que ya dispone de lo siguiente:

En esta sección, va a instalar los controladores de NVIDIA directamente en el sistema operativo SUSE Linux Micro, ya que el controlador de código abierto de NVIDIA ahora forma parte de los repositorios de paquetes principales de SUSE Linux Micro. De esta forma, basta con instalar los paquetes RPM necesarios. No es necesario compilar ni descargar paquetes ejecutables. A continuación, le guiaremos a través del despliegue de la generación "G06" del controlador, que admite las GPU más recientes (consulte este documento para obtener más información). Debe seleccionar la generación adecuada del controlador de GPU de NVIDIA de su sistema. Para las GPU modernas, el controlador "G06" es la opción más habitual.

Antes de comenzar, tenga en cuenta que, además del controlador de código abierto de NVIDIA que SUSE incluye en SUSE Linux Micro, es posible que necesite componentes adicionales de NVIDIA para su configuración. Por ejemplo, bibliotecas OpenGL, kits de herramientas CUDA, utilidades de línea de comandos como nvidia-smi y componentes de integración de contenedores como nvidia-container-toolkit. SUSE no suministra muchos de estos componentes, ya sea porque son software propiedad de NVIDIA o porque no tiene sentido que los suministremos nosotros en lugar de NVIDIA. Por lo tanto, como parte de las instrucciones, configuraremos repositorios adicionales que nos den acceso a dichos componentes y veremos algunos ejemplos de uso de estas herramientas, de modo que el sistema resultante será totalmente funcional. Es importante distinguir entre los repositorios de SUSE y los de NVIDIA, ya que en ocasiones puede haber una discrepancia entre las versiones de los paquetes que NVIDIA pone a disposición y las que SUSE ha creado. Esto suele ocurrir cuando SUSE lanza una nueva versión del controlador de código abierto y pasan un par de días antes de que los paquetes equivalentes estén disponibles en los repositorios de NVIDIA.

Le recomendamos que se asegure de que la versión del controlador que selecciona sea compatible con su GPU y cumpla con los requisitos de CUDA que pueda tener. Compruebe lo siguiente:

Sugerencia

Para localizar las versiones del controlador de código abierto de NVIDIA, ejecute zypper se -s nvidia-open-driver en el equipo de destino o busque "nvidia-open-driver" en el Centro de servicios al cliente de SUSE en SUSE Linux Micro 6.1 para AMD64/Intel 64.

Cuando haya confirmado que hay una versión equivalente disponible en los repositorios de NVIDIA, podrá instalar los paquetes en el sistema operativo host. Para ello, debemos abrir una sesión transactional-update, que crea una nueva instantánea de lectura/escritura del sistema operativo subyacente para que podamos realizar cambios en la plataforma inmutable (para obtener más instrucciones sobre transactional-update, consulte este documento):

transactional-update shell

Cuando acceda a la shell transactional-update, añada un repositorio de paquetes adicional de NVIDIA. Esto nos permite incorporar utilidades adicionales, por ejemplo, nvidia-smi:

zypper ar https://download.nvidia.com/suse/sle15sp6/ nvidia-suse-main
zypper --gpg-auto-import-keys refresh

A continuación, puede instalar el controlador y nvidia-compute-utils para obtener utilidades adicionales. Si no necesita las utilidades, puede omitirlas, pero para fines de prueba, vale la pena instalarlas en esta etapa:

zypper install -y --auto-agree-with-licenses nvidia-open-driver-G06-signed-kmp nvidia-compute-utils-G06

Nota

Si la instalación falla, podría deberse a una incompatibilidad entre la versión del controlador seleccionada y la que NVIDIA incluye en sus repositorios. Consulte la sección anterior para verificar que las versiones coincidan. Pruebe a instalar una versión diferente del controlador. Por ejemplo, si los repositorios de NVIDIA tienen una versión anterior, puede especificar nvidia-open-driver-G06-signed-kmp=550.54.14 en su comando de instalación para especificar una versión que coincida.

A continuación, si no utiliza una GPU compatible (recuerde que la lista está aquí), puede comprobar si el controlador funciona habilitando la compatibilidad a nivel de módulo, pero los resultados pueden variar. Omita este paso si utiliza una GPU compatible:

sed -i '/NVreg_OpenRmEnableUnsupportedGpus/s/^#//g' /etc/modprobe.d/50-nvidia-default.conf

Ahora que ha instalado estos paquetes, es el momento de salir de la sesión transactional-update:

exit

Nota

Asegúrese de haber salido de la sesión transactional-update antes de continuar.

Después de instalar los controladores, reinicie. Dado que SUSE Linux Micro es un sistema operativo inmutable, es necesario reiniciar en la nueva instantánea que ha creado en el paso anterior. Los controladores solo se instalan en esta nueva instantánea, por lo que no es posible cargarlos sin reiniciar en ella, lo cual se realiza automáticamente. Ejecute el comando de reinicio cuando esté listo:

reboot

Una vez que el sistema se haya reiniciado correctamente, vuelva a iniciar sesión y use la herramienta nvidia-smi para comprobar que el controlador se ha cargado correctamente y que puede acceder y mostrar sus GPU:

nvidia-smi

El resultado de este comando debería mostrar algo similar a lo siguiente, teniendo en cuenta que en este ejemplo tenemos dos GPU:

+---------------------------------------------------------------------------------------+
| NVIDIA-SMI 545.29.06              Driver Version: 545.29.06    CUDA Version: 12.3     |
|-----------------------------------------+----------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |
|                                         |                      |               MIG M. |
|=========================================+======================+======================|
|   0  NVIDIA A100-PCIE-40GB          Off | 00000000:17:00.0 Off |                    0 |
| N/A   29C    P0              35W / 250W |      4MiB / 40960MiB |      0%      Default |
|                                         |                      |             Disabled |
+-----------------------------------------+----------------------+----------------------+
|   1  NVIDIA A100-PCIE-40GB          Off | 00000000:CA:00.0 Off |                    0 |
| N/A   30C    P0              33W / 250W |      4MiB / 40960MiB |      0%      Default |
|                                         |                      |             Disabled |
+-----------------------------------------+----------------------+----------------------+

+---------------------------------------------------------------------------------------+
| Processes:                                                                            |
|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |
|        ID   ID                                                             Usage      |
|=======================================================================================|
|  No running processes found                                                           |
+---------------------------------------------------------------------------------------+

Con esto concluye el proceso de instalación y verificación de los controladores NVIDIA en su sistema SUSE Linux Micro.

En esta fase, lo único que hemos podido verificar es que, a nivel del host, se puede acceder al dispositivo NVIDIA y que los controladores se cargan correctamente. Sin embargo, si queremos asegurarnos de que funcionan, una prueba sencilla sería validar que la GPU puede recibir instrucciones de una aplicación del espacio de usuarios, idealmente a través de un contenedor y mediante la biblioteca CUDA, ya que eso es lo que normalmente utilizaría una carga de trabajo real. Para ello, podemos realizar una modificación adicional en el sistema operativo del host instalando nvidia-container-toolkit (NVIDIA Container Toolkit). En primer lugar, abra otra shell transactional-update, teniendo en cuenta que podríamos haberlo hecho en una sola transacción en el paso anterior. Veremos cómo hacerlo de forma totalmente automatizada en una sección posterior:

transactional-update shell

A continuación, instale el paquete nvidia-container-toolkit desde el repositorio de NVIDIA Container Toolkit:

zypper ar https://nvidia.github.io/libnvidia-container/stable/rpm/nvidia-container-toolkit.repo
zypper --gpg-auto-import-keys install -y nvidia-container-toolkit

Cuando esté listo, puede salir de la shell transactional-update:

exit

... y reiniciar el equipo en la nueva instantánea:

reboot

Nota

Como antes, debe asegurarse de que ha salido de transactional-shell y ha reiniciado el equipo para que los cambios surtan efecto.

Una vez reiniciada el equipo, compruebe que el sistema puede mostrar correctamente los dispositivos que usan NVIDIA Container Toolkit. El resultado debe ser detallado, con mensajes INFO y WARN, pero sin mensajes ERROR:

nvidia-ctk cdi generate --output=/etc/cdi/nvidia.yaml

Esto garantiza que cualquier contenedor iniciado en el equipo pueda emplear los dispositivos GPU NVIDIA que se hayan detectado. Cuando esté listo, ejecute un contenedor basado en Podman. Ejecutarlo con Podman es una buena forma de validar el acceso al dispositivo NVIDIA desde dentro de un contenedor, lo que debería dar confianza para hacer lo mismo con Kubernetes en una fase posterior. Otorgue a Podman acceso a los dispositivos NVIDIA etiquetados que se gestionaron con el comando anterior, basándose en SLE BCI y ejecute el comando Bash:

podman run --rm --device nvidia.com/gpu=all --security-opt=label=disable -it registry.suse.com/bci/bci-base:latest bash

Ahora ejecutará comandos desde un contenedor de Podman temporal. No tiene acceso a su sistema subyacente y es efímero, por lo que cualquier acción que realicemos aquí no será permanente y no debería poder dañar nada en el host subyacente. Como ahora estamos en un contenedor, podemos instalar las bibliotecas CUDA necesarias, comprobando de nuevo la versión correcta de CUDA para su controlador aquí, aunque el resultado anterior de nvidia-smi debería mostrar la versión de CUDA necesaria. En el ejemplo siguiente, vamos a instalar CUDA 12.3 y a extraer muchos ejemplos, demostraciones y kits de desarrollo para que pueda validar completamente la GPU:

zypper ar https://developer.download.nvidia.com/compute/cuda/repos/sles15/x86_64/ cuda-suse
zypper in -y cuda-libraries-devel-12-3 cuda-minimal-build-12-3 cuda-demo-suite-12-3

Cuando se haya instalado correctamente, no salga del contenedor. Ejecutaremos el ejemplo de CUDA deviceQuery, que valida de forma exhaustiva el acceso a la GPU a través de CUDA, y desde el propio contenedor:

/usr/local/cuda-12/extras/demo_suite/deviceQuery

Si todo va bien, debería ver un resultado similar al siguiente. Fíjese en el mensaje Result = PASS al final del comando y en que, en el resultado, el sistema identifica correctamente dos GPU, mientras que es posible que su entorno solo tenga una:

/usr/local/cuda-12/extras/demo_suite/deviceQuery Starting...

 CUDA Device Query (Runtime API) version (CUDART static linking)

Detected 2 CUDA Capable device(s)

Device 0: "NVIDIA A100-PCIE-40GB"
  CUDA Driver Version / Runtime Version          12.2 / 12.1
  CUDA Capability Major/Minor version number:    8.0
  Total amount of global memory:                 40339 MBytes (42298834944 bytes)
  (108) Multiprocessors, ( 64) CUDA Cores/MP:     6912 CUDA Cores
  GPU Max Clock rate:                            1410 MHz (1.41 GHz)
  Memory Clock rate:                             1215 Mhz
  Memory Bus Width:                              5120-bit
  L2 Cache Size:                                 41943040 bytes
  Maximum Texture Dimension Size (x,y,z)         1D=(131072), 2D=(131072, 65536), 3D=(16384, 16384, 16384)
  Maximum Layered 1D Texture Size, (num) layers  1D=(32768), 2048 layers
  Maximum Layered 2D Texture Size, (num) layers  2D=(32768, 32768), 2048 layers
  Total amount of constant memory:               65536 bytes
  Total amount of shared memory per block:       49152 bytes
  Total number of registers available per block: 65536
  Warp size:                                     32
  Maximum number of threads per multiprocessor:  2048
  Maximum number of threads per block:           1024
  Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
  Max dimension size of a grid size    (x,y,z): (2147483647, 65535, 65535)
  Maximum memory pitch:                          2147483647 bytes
  Texture alignment:                             512 bytes
  Concurrent copy and kernel execution:          Yes with 3 copy engine(s)
  Run time limit on kernels:                     No
  Integrated GPU sharing Host Memory:            No
  Support host page-locked memory mapping:       Yes
  Alignment requirement for Surfaces:            Yes
  Device has ECC support:                        Enabled
  Device supports Unified Addressing (UVA):      Yes
  Device supports Compute Preemption:            Yes
  Supports Cooperative Kernel Launch:            Yes
  Supports MultiDevice Co-op Kernel Launch:      Yes
  Device PCI Domain ID / Bus ID / location ID:   0 / 23 / 0
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >

Device 1: <snip to reduce output for multiple devices>
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >
> Peer access from NVIDIA A100-PCIE-40GB (GPU0) -> NVIDIA A100-PCIE-40GB (GPU1) : Yes
> Peer access from NVIDIA A100-PCIE-40GB (GPU1) -> NVIDIA A100-PCIE-40GB (GPU0) : Yes

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 12.3, CUDA Runtime Version = 12.3, NumDevs = 2, Device0 = NVIDIA A100-PCIE-40GB, Device1 = NVIDIA A100-PCIE-40GB
Result = PASS

Desde aquí, puede continuar ejecutando cualquier otra carga de trabajo CUDA. Utilice compiladores y cualquier otro aspecto del ecosistema CUDA para realizar más pruebas. Cuando haya terminado, puede salir del contenedor, pero tenga en cuenta que todo lo que haya instalado en él es efímero (por lo que se perderá) y no ha afectado al sistema operativo subyacente:

exit

Ahora que hemos probado la instalación y el uso del controlador de código abierto de NVIDIA en SUSE Linux Micro, veamos cómo configurar Kubernetes en el mismo equipo. Esta guía no le guiará a través del despliegue de Kubernetes, pero se entiende que ha instalado K3s o RKE2 y que su kubeconfig se ha configurado en consecuencia, de modo que puede ejecutar como superusuario los comandos estándares de kubectl. Se sobrentiende que su nodo forma un clúster de un solo nodo, aunque los pasos básicos deberían ser similares para clústeres de varios nodos. En primer lugar, asegúrese de que su acceso a kubectl funciona:

kubectl get nodes

Esto debería mostrar algo similar a lo siguiente:

NAME       STATUS   ROLES                       AGE   VERSION
node0001   Ready    control-plane,etcd,master   13d   v1.32.4+rke2r1

Debería ver que su instalación de k3s/rke2 ha detectado NVIDIA Container Toolkit en el host y ha configurado automáticamente la integración del entorno de ejecución de NVIDIA en containerd (la interfaz de entorno de ejecución de contenedores que utiliza k3s/rke2). Confírmelo comprobando el archivo config.toml de containerd:

tail -n8 /var/lib/rancher/rke2/agent/etc/containerd/config.toml

El resultado debe ser similar a lo siguiente. La ubicación equivalente de K3s es /var/lib/rancher/k3s/agent/etc/containerd/config.toml:

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes."nvidia"]
  runtime_type = "io.containerd.runc.v2"
[plugins."io.containerd.grpc.v1.cri".containerd.runtimes."nvidia".options]
  BinaryName = "/usr/bin/nvidia-container-runtime"

Nota

Si estas entradas no están presentes, es posible que la detección haya fallado. Podría deberse a que el equipo o los servicios de Kubernetes no se han reiniciado. Si es necesario, añádalos manualmente como se indica anteriormente.

A continuación, debemos configurar RuntimeClass de NVIDIA como entorno de ejecución adicional al predeterminado de Kubernetes, lo que garantiza que cualquier solicitud de pods que haga el usuario y que necesite acceder a la GPU pueda utilizar NVIDIA Container Toolkit para hacerlo, a través de nvidia-container-runtime, tal y como se configura en containerd:

kubectl apply -f - <<EOF
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: nvidia
handler: nvidia
EOF

El siguiente paso es configurar el complemento de dispositivos de NVIDIA. Este complemento configura Kubernetes para aprovechar las GPU NVIDIA como recursos que se pueden utilizar dentro del clúster, en combinación con NVIDIA Container Toolkit. Esta herramienta detecta inicialmente todas las capacidades del host subyacente, incluidas las GPU, los controladores y otras (como GL) y, luego, permite solicitar recursos de GPU y consumirlos como parte de sus aplicaciones.

Primero, debe añadir y actualizar el repositorio de Helm para el complemento de dispositivos de NVIDIA:

helm repo add nvdp https://nvidia.github.io/k8s-device-plugin
helm repo update

Ahora puede instalar el complemento de dispositivos de NVIDIA:

helm upgrade -i nvdp nvdp/nvidia-device-plugin --namespace nvidia-device-plugin --create-namespace --version 0.14.5 --set runtimeClassName=nvidia

Después de unos minutos, verá un nuevo pod en ejecución que completará la detección en los nodos disponibles y los etiquetará con el número de GPU que se han detectado:

kubectl get pods -n nvidia-device-plugin
NAME                              READY   STATUS    RESTARTS      AGE
nvdp-nvidia-device-plugin-jp697   1/1     Running   2 (12h ago)   6d3h

kubectl get node node0001 -o json | jq .status.capacity
{
  "cpu": "128",
  "ephemeral-storage": "466889732Ki",
  "hugepages-1Gi": "0",
  "hugepages-2Mi": "0",
  "memory": "32545636Ki",
  "nvidia.com/gpu": "1",                      <----
  "pods": "110"
}

Ahora ya está listo para crear un pod de NVIDIA que intentará utilizar esta GPU. Probemos con el contenedor CUDA Benchmark:

kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: nbody-gpu-benchmark
  namespace: default
spec:
  restartPolicy: OnFailure
  runtimeClassName: nvidia
  containers:
  - name: cuda-container
    image: nvcr.io/nvidia/k8s/cuda-sample:nbody
    args: ["nbody", "-gpu", "-benchmark"]
    resources:
      limits:
        nvidia.com/gpu: 1
    env:
    - name: NVIDIA_VISIBLE_DEVICES
      value: all
    - name: NVIDIA_DRIVER_CAPABILITIES
      value: all
EOF

Si todo ha ido bien, puede consultar los registros y ver la información del benchmark:

kubectl logs nbody-gpu-benchmark
Run "nbody -benchmark [-numbodies=<numBodies>]" to measure performance.
	-fullscreen       (run n-body simulation in fullscreen mode)
	-fp64             (use double precision floating point values for simulation)
	-hostmem          (stores simulation data in host memory)
	-benchmark        (run benchmark to measure performance)
	-numbodies=<N>    (number of bodies (>= 1) to run in simulation)
	-device=<d>       (where d=0,1,2.... for the CUDA device to use)
	-numdevices=<i>   (where i=(number of CUDA devices > 0) to use for simulation)
	-compare          (compares simulation results running once on the default GPU and once on the CPU)
	-cpu              (run n-body simulation on the CPU)
	-tipsy=<file.bin> (load a tipsy model file for simulation)

NOTE: The CUDA Samples are not meant for performance measurements. Results may vary when GPU Boost is enabled.

> Windowed mode
> Simulation data stored in video memory
> Single precision floating point simulation
> 1 Devices used for simulation
GPU Device 0: "Turing" with compute capability 7.5

> Compute 7.5 CUDA device: [Tesla T4]
40960 bodies, total time for 10 iterations: 101.677 ms
= 165.005 billion interactions per second
= 3300.103 single-precision GFLOP/s at 20 flops per interaction

Por último, si sus aplicaciones requieren OpenGL, puede instalar las bibliotecas de OpenGL de NVIDIA necesarias en el nivel del host. El complemento de dispositivos de NVIDIA y NVIDIA Container Toolkit las pondrán a disposición de los contenedores. Para ello, instale el paquete de la siguiente manera:

transactional-update pkg install nvidia-gl-G06

Nota

Debe rearrancar el sistema para que este paquete esté disponible para sus aplicaciones. El complemento de dispositivos de NVIDIA debería volver a detectarlo automáticamente mediante NVIDIA Container Toolkit.

Ya ha demostrado la plena funcionalidad de sus aplicaciones y GPU en SUSE Linux Micro y ahora desea utilizar Capítulo 11, Edge Image Builder para unificarlo todo en una imagen de disco ISO o RAW desplegable/consumible. Esta guía no explica cómo usar Edge Image Builder, pero proporciona las configuraciones necesarias para crear dicha imagen. A continuación encontrará un ejemplo de definición de imagen, junto con los archivos de configuración de Kubernetes necesarios, para garantizar que todos los componentes requeridos se desplieguen. Esta es la estructura de directorio de Edge Image Builder para el ejemplo que se muestra a continuación:

.
├── base-images
│   └── SL-Micro.x86_64-6.1-Base-SelfInstall-GM.install.iso
├── eib-config-iso.yaml
├── kubernetes
│   ├── config
│   │   └── server.yaml
│   ├── helm
│   │   └── values
│   │       └── nvidia-device-plugin.yaml
│   └── manifests
│       └── nvidia-runtime-class.yaml
└── rpms
    └── gpg-keys
        └── nvidia-container-toolkit.key

Exploremos esos archivos. En primer lugar, hay una definición de imagen de muestra para un clúster de un solo nodo que ejecuta K3s y que despliega las utilidades y los paquetes OpenGL (eib-config-iso.yaml):

apiVersion: 1.2
image:
  arch: x86_64
  imageType: iso
  baseImage: SL-Micro.x86_64-6.1-Base-SelfInstall-GM.install.iso
  outputImageName: deployimage.iso
operatingSystem:
  time:
    timezone: Europe/London
    ntp:
      pools:
        - 2.suse.pool.ntp.org
  isoConfiguration:
    installDevice: /dev/sda
  users:
    - username: root
      encryptedPassword: $6$XcQN1xkuQKjWEtQG$WbhV80rbveDLJDz1c93K5Ga9JDjt3mF.ZUnhYtsS7uE52FR8mmT8Cnii/JPeFk9jzQO6eapESYZesZHO9EslD1
  packages:
    packageList:
      - nvidia-open-driver-G06-signed-kmp-default
      - nvidia-compute-utils-G06
      - nvidia-gl-G06
      - nvidia-container-toolkit
    additionalRepos:
      - url: https://download.nvidia.com/suse/sle15sp6/
      - url: https://nvidia.github.io/libnvidia-container/stable/rpm/x86_64
    sccRegistrationCode: [snip]
kubernetes:
  version: v1.32.4+k3s1
  helm:
    charts:
      - name: nvidia-device-plugin
        version: v0.14.5
        installationNamespace: kube-system
        targetNamespace: nvidia-device-plugin
        createNamespace: true
        valuesFile: nvidia-device-plugin.yaml
        repositoryName: nvidia
    repositories:
      - name: nvidia
        url: https://nvidia.github.io/k8s-device-plugin

Nota

Esto es solo un ejemplo. Deberá personalizarlo según sus necesidades y expectativas. Además, si utiliza SUSE Linux Micro, debe proporcionar su propio código sccRegistrationCode para resolver las dependencias del paquete y conseguir los controladores de NVIDIA.

Además, debemos añadir componentes adicionales para que Kubernetes los cargue durante el arranque. El directorio de EIB necesita primero un directorio kubernetes, con subdirectorios para la configuración, los valores del chart de Helm y cualquier manifiesto adicional que sea necesario:

mkdir -p kubernetes/config kubernetes/helm/values kubernetes/manifests

Ahora vamos a configurar Kubernetes (opcional) eligiendo una CNI (por defecto es Cilium si no se selecciona ninguna) y habilitando SELinux:

cat << EOF > kubernetes/config/server.yaml
cni: cilium
selinux: true
EOF

Ahora, asegúrese de que se haya creado RuntimeClass de NVIDIA en el clúster de Kubernetes:

cat << EOF > kubernetes/manifests/nvidia-runtime-class.yaml
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: nvidia
handler: nvidia
EOF

Usamos la versión integrada de Helm Controller para desplegar el complemento de dispositivos de NVIDIA a través del propio Kubernetes. Proporcionemos la clase de tiempo de ejecución en el archivo de valores para el chart:

cat << EOF > kubernetes/helm/values/nvidia-device-plugin.yaml
runtimeClassName: nvidia
EOF

Antes de continuar, debemos obtener la clave pública del RPM de NVIDIA Container Toolkit:

mkdir -p rpms/gpg-keys
curl -o rpms/gpg-keys/nvidia-container-toolkit.key https://nvidia.github.io/libnvidia-container/gpgkey

Todos los artefactos necesarios, incluidos el binario de Kubernetes, las imágenes de contenedores, los charts de Helm (y cualquier imagen referenciada), se aislarán automáticamente, lo que significa que, en el momento del despliegue, los sistemas no deberían requerir conexión a Internet de forma predeterminada. Ahora solo tiene que obtener la imagen ISO de SUSE Linux Micro de la página de descargas de SUSE (y colocarla en el directorio base-images). Puede generar la imagen ISO con Edge Image Builder. Para completar el ejemplo, este es el comando que se utilizó para crear la imagen:

podman run --rm --privileged -it -v /path/to/eib-files/:/eib \
registry.suse.com/edge/3.3/edge-image-builder:1.2.1 \
build --definition-file eib-config-iso.yaml

Para obtener más información, consulte la documentación de Edge Image Builder.